resumeforge 0.1.0__py3-none-any.whl

resumeforge/adapters/fpdf_adapter.py

@@ -0,0 +1,63 @@
+"""Adapter that converts RCSS declarations into fpdf2 rendering instructions."""
+
+from dataclasses import dataclass, field
+from enum import Enum
+
+from resumeforge.models import Declaration
+
+
+class DisplayMode(Enum):
+    """Determines which fpdf2 write method to use for section content."""
+    BLOCK = "block"    # → multi_cell
+    INLINE = "inline"  # → cell
+
+
+@dataclass
+class SectionRenderStyle:
+    """Adapted RCSS declarations for PDF rendering.
+
+    Separates declarations into state mutations applied before writing
+    content, parameters passed to the write call, and the display mode
+    that determines which write method to use.
+    """
+    state_setters: list[callable] = field(default_factory=list)
+    write_params: dict = field(default_factory=dict)
+    display: DisplayMode = DisplayMode.BLOCK
+
+
+def _hex_to_rgb(hex_color: str) -> tuple[int, int, int]:
+    """Convert a hex color string like '#333333' to an (r, g, b) tuple."""
+    h = hex_color.lstrip("#")
+    return (int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16))
+
+
+# State setters — mutate pdf state before writing content
+STATE_HANDLERS = {
+    "font-size": lambda values: lambda pdf: pdf.set_font_size(float(values[0].replace("pt", ""))),
+    "color": lambda values: lambda pdf: pdf.set_text_color(*_hex_to_rgb(values[0])),
+    "background-color": lambda values: lambda pdf: pdf.set_fill_color(*_hex_to_rgb(values[0])),
+}
+
+# Write params — passed to multi_cell/cell at write time
+WRITE_PARAM_HANDLERS = {
+    "align": lambda values: ("align", values[0][0].upper()),
+    "line-height": lambda values: ("h", float(values[0])),
+}
+
+
+def adapt_declarations(declarations: list[Declaration]) -> SectionRenderStyle:
+    """Convert RCSS declarations into a SectionRenderStyle for rendering.
+
+    Classifies each declaration as a state setter, a write parameter,
+    or a display mode directive.
+    """
+    style = SectionRenderStyle()
+    for decl in declarations:
+        if decl.property == "display":
+            style.display = DisplayMode(decl.values[0])
+        elif decl.property in STATE_HANDLERS:
+            style.state_setters.append(STATE_HANDLERS[decl.property](decl.values))
+        elif decl.property in WRITE_PARAM_HANDLERS:
+            key, value = WRITE_PARAM_HANDLERS[decl.property](decl.values)
+            style.write_params[key] = value
+    return style

resumeforge/adapters/heading_adapter.py

@@ -0,0 +1,44 @@
+from dataclasses import dataclass
+
+from resumeforge.models import StyledHeading
+
+@dataclass
+class HeadingConfig:
+    content: str
+    font_size: int
+    align: str
+    line_height: int
+    color: str | None = None
+
+
+def adapt_heading(heading: StyledHeading | None) -> HeadingConfig | None:
+    """Convert a StyledHeading into a typed HeadingConfig for the render engine.
+
+    Applies ATS-friendly defaults (font_size=20, align=center, line_height=7)
+    and overrides with any user-specified declarations from the heading rule.
+    Returns None if heading is None (no heading content in CV).
+
+    TODO: Refactor to use _DECLARATION_ADAPTERS map and produce state_setters
+    (pdf-mutating callables) like fpdf_adapter does for SectionRenderStyle.
+    This would remove manual type conversion here and hex-to-rgb in the engine.
+    """
+    if heading is None:
+        return None
+
+    props = {
+        "content": heading.content,
+        "font_size": 20,
+        "align": "center",
+        "line_height": 7,
+    }
+
+    if heading.rule:
+        for decl in heading.rule.declarations:
+            key = decl.property.replace("-", "_")
+            value = decl.values[0]
+            if key == "font_size":
+                value = int(value.rstrip("pt"))
+            elif key == "line_height":
+                value = int(value)
+            props[key] = value
+    return HeadingConfig(**props)

resumeforge/adapters/layout_adapter.py

@@ -0,0 +1,33 @@
+from dataclasses import dataclass
+from typing import Any, Callable
+from resumeforge.models import LayoutRule, Declaration
+
+@dataclass
+class LayoutConfig:
+    """renderer friendly layout configs from Layout Stylesheet (rcss)"""
+    mode: str
+    columns: int
+    column_widths: list[int]
+    column_gap: float
+    margins: tuple[float, float, float, float]
+    font_family: str | None = None
+
+_DECLARATION_ADAPTERS: dict[str, Callable[[Declaration], Any]] = {
+    "mode": lambda d: d.values[0],
+    "columns": lambda d: int(d.values[0]),
+    "column-widths": lambda d: [int(v.rstrip("%")) for v in d.values],
+    "column-gap": lambda d: float(d.values[0].rstrip("mm")),
+    "margins": lambda d: tuple(float(v.rstrip("mm")) for v in d.values),
+    "font-family": lambda d: d.values[0].strip('"'),
+}
+
+def adapt_layout(layout: LayoutRule) -> LayoutConfig:
+    props = {"column_widths": [50, 50]}
+    for decl in layout.declarations:
+        decl_adatper = _DECLARATION_ADAPTERS.get(decl.property)
+        if decl_adatper:
+            key = decl.property.replace("-", "_")
+            props[key] = decl_adatper(decl)
+        else:
+            raise ValueError(f"layout property '{decl.property}' is not valid")
+    return LayoutConfig(**props)

resumeforge/cli.py

@@ -0,0 +1,109 @@
+"""ResumeForge CLI entry point."""
+
+import argparse
+import sys
+from pathlib import Path
+
+from resumeforge.parser import RcssParser
+from resumeforge.transformer import transform
+from resumeforge.mappers.section_mapper import SectionMapper
+from resumeforge.mappers.heading_mapper import map as map_heading
+from resumeforge.renderer import Renderer
+from resumeforge.adapters.fpdf_adapter import adapt_declarations
+from resumeforge.adapters.layout_adapter import adapt_layout
+from resumeforge.engines.fpdf_engine import fpdf_engine
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="resumeforge",
+        description="Convert plain-text CVs into styled A4 PDFs using RCSS.",
+    )
+    subparsers = parser.add_subparsers(dest="command")
+
+    # render cv txt to pdf command using rcss style file (formatting, style rules)
+    render = subparsers.add_parser("render", help="Render a resume to PDF")
+    render.add_argument("--input", required=True, help="Path to input .txt file")
+    render.add_argument("--style", required=True, help="Path to .rcss style file")
+    render.add_argument("--output", default="output.pdf", help="Output PDF path")
+
+    # validate your rcss style file
+    validate = subparsers.add_parser("validate", help="Validate RCSS syntax")                                                                                                      
+    validate.add_argument("--style", required=True, help="Path to .rcss file to validate") 
+
+    # check the cli version
+    subparsers.add_parser("version", help="Show version")
+
+    return parser
+
+def cmd_render(args) -> int:
+    """Render a resume for .txt + .rcss to PDF."""
+
+    # TODO - align the 'logging' pattern between all components
+
+    # 1. Parse the RCSS style file into a tree
+    print("[1/4] ✓ Parsing RCSS style file")
+    raw_rcss = Path(args.style).read_text()
+    result = RcssParser().parse(text=raw_rcss, options={"debug": True})
+    if not result.valid:
+        print(f"[1/4] ✗ Invalid RCSS: {result.message}")
+        return 1
+
+    # 2. Transform tree into domain models (layout, sections, declarations)
+    print("[2/4] ✓ Transforming parse tree to stylesheet")
+    stylesheet = transform(tree=result.tree, options={"debug": True})
+   
+    # 3. Map raw text sections to their style sheet rules
+    print("[3/4] ✓ Mapping CV sections to style rules")
+    cv_text = Path(args.input).read_text()
+    styled_heading = map_heading(cv_text, stylesheet)
+    styled_sections = SectionMapper(options={"debug":True}).map(text=cv_text, stylesheet=stylesheet)
+    
+    # 4. Render PDF from input .txt using transformed style models
+    print("[4/4] ✓ Rendering PDF")
+    Renderer(adapter=adapt_declarations, engine=fpdf_engine, layout_adapter=adapt_layout).render(
+        sections=styled_sections, 
+        layout=stylesheet.layout, 
+        output_path=args.output, 
+        font_face=stylesheet.font_face,
+        heading=styled_heading
+    )
+    return 0
+
+def cmd_validate(args) -> int:
+    """Validate RCSS syntax and reports errors to stdout"""
+    text = Path(args.style).read_text()
+    validtion_result = RcssParser().validate(text)
+
+    if validtion_result.valid:
+        print("Valid RCSS")
+        return 0
+    else:
+        print(f"Invalid RCSS: {validtion_result.message}")
+        return 1
+
+def cmd_version(args) -> int:
+    """Print the current version."""
+    print("resumeforge 0.1.0")
+    return 0
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    commands = {
+        "validate": cmd_validate,
+        "version": cmd_version,
+        "render": cmd_render
+    }
+
+    handler = commands.get(args.command)
+    if handler:
+        return handler(args)
+  
+    parser.print_help()
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

resumeforge/constants.py

@@ -0,0 +1,13 @@
+"""Default CV typography constants.
+
+Used as fallbacks when no overrides are specified in @font-face or section rules.
+Based on professional tech CV recommendations: clear, conservative, ATS-friendly.
+"""
+
+DEFAULTS = {
+    "font-family": "Helvetica",
+    "heading-font-size": 12,       # section headings: 11-14pt bold
+    "body-font-size": 11,          # body content: 10.5-12pt regular
+    "title-font-size": 22,         # name/title: 20-26pt bold
+    "line-height": 5,              # ~1.1 spacing in mm
+}

resumeforge/engines/fpdf_engine.py

@@ -0,0 +1,152 @@
+"""fpdf2 render engine — writes RenderSections to a PDF file."""
+
+from fpdf import FPDF
+
+from resumeforge.models import FontFaceRule
+from resumeforge.renderer import RenderSection
+from resumeforge.adapters.fpdf_adapter import DisplayMode
+from resumeforge.adapters.layout_adapter import LayoutConfig
+from resumeforge.adapters.heading_adapter import HeadingConfig
+from resumeforge.constants import DEFAULTS
+
+
+def _get_font_face_value(font_face: FontFaceRule | None, prop: str, default=None):
+    """Extract a value from font_face declarations."""
+    if font_face is None:
+        return default
+    for d in font_face.declarations:
+        if d.property == prop:
+            return d.values[0].strip('"')
+    return default
+
+
+def _register_fonts(pdf: FPDF, font_face: FontFaceRule | None) -> str:
+    """Register custom fonts from @font-face and return the font family name."""
+    if font_face is None:
+        return DEFAULTS["font-family"]
+
+    family = _get_font_face_value(font_face, "font-family", DEFAULTS["font-family"])
+    src = _get_font_face_value(font_face, "src")
+    src_bold = _get_font_face_value(font_face, "src-bold")
+
+    if src:
+        pdf.add_font(family, "", src)
+    if src_bold:
+        pdf.add_font(family, "B", src_bold)
+
+    return family
+
+def _render_heading(pdf: FPDF, heading_config: HeadingConfig | None, font_family: str) -> None:
+    """Render heading with Applicant name, contact info and role/title information."""
+    if heading_config is None:
+        return
+
+    lines = heading_config.content.splitlines()
+    if not lines:
+        return
+
+    font_size = int(heading_config.font_size) if isinstance(heading_config.font_size, str) else heading_config.font_size
+    line_height = int(heading_config.line_height) if isinstance(heading_config.line_height, str) else heading_config.line_height
+    align = heading_config.align[0].upper()  # "center" -> "C", "left" -> "L", "right" -> "R"
+
+    # First line: name — bold, always black
+    pdf.set_text_color(0, 0, 0)
+    pdf.set_font(font_family, style="B", size=font_size)
+    pdf.multi_cell(w=0, h=line_height, text=lines[0], align=align, new_x="LMARGIN", new_y="NEXT")
+
+    # Remaining lines: contact/title — regular, scaled down, with color if set
+    if len(lines) > 1:
+        if heading_config.color:
+            # TODO: extract hex-to-rgb conversion to a shared adapter utility
+            r, g, b = int(heading_config.color[1:3], 16), int(heading_config.color[3:5], 16), int(heading_config.color[5:7], 16)
+            pdf.set_text_color(r, g, b)
+        contact_size = round(font_size * 0.55)
+        pdf.set_font(font_family, style="", size=contact_size)
+        for line in lines[1:]:
+            if line.strip():
+                pdf.multi_cell(w=0, h=line_height, text=line, align=align, new_x="LMARGIN", new_y="NEXT")
+
+    # Reset for subsequent sections
+    pdf.set_text_color(0, 0, 0)
+    pdf.ln(line_height)
+
+
+def _render_single(pdf: FPDF, sections: list[RenderSection], font_family: str) -> None:
+    """Render sections sequentially in a single column."""
+    for section in sections:
+        _apply_and_write(pdf, section, w=0, font_family=font_family)
+
+
+def _render_grid(pdf: FPDF, sections: list[RenderSection], layout_config: LayoutConfig, font_family: str) -> None:
+    """Render sections into a 2-column grid layout."""
+    gap = layout_config.column_gap
+    page_w = pdf.epw
+    usable_w = page_w - gap
+    col_widths = [usable_w * w / 100 for w in layout_config.column_widths]
+    col_x = [pdf.l_margin, pdf.l_margin + col_widths[0] + gap]
+    col_y = [pdf.get_y(), pdf.get_y()]
+
+    for section in sections:
+        col = (section.grid_column or 1) - 1
+        pdf.set_xy(col_x[col], col_y[col])
+        _apply_and_write(pdf, section, w=col_widths[col], x_after=col_x[col], font_family=font_family)
+        col_y[col] = pdf.get_y()
+
+
+def _apply_and_write(pdf: FPDF, section: RenderSection, w: float, font_family: str, x_after: float | None = None) -> None:
+    """Apply state setters, write heading in bold, then write section content."""
+    new_x = "LEFT" if x_after is not None else "LMARGIN"
+
+    # Reset state to defaults before applying section overrides
+    pdf.set_text_color(0, 0, 0)
+    pdf.set_font_size(DEFAULTS["body-font-size"])
+
+    # Apply section-level style overrides (font-size, color, etc.)
+    for setter in section.style.state_setters:
+        setter(pdf)
+
+    # Resolve sizes: use section style if set, otherwise defaults
+    heading_size = pdf.font_size_pt or DEFAULTS["heading-font-size"]
+    body_size = pdf.font_size_pt or DEFAULTS["body-font-size"]
+    line_h = section.style.write_params.get("h", DEFAULTS["line-height"])
+
+    # Write section heading — bold, always black
+    pdf.set_text_color(0, 0, 0)
+    pdf.set_font(font_family, style="B", size=heading_size)
+    pdf.multi_cell(w=w, h=line_h, text=section.name, new_x=new_x, new_y="NEXT")
+
+    # Re-apply style setters (list of callables from SectionRenderStyle) to restore
+    # section color for body content — each setter is a lambda that mutates pdf state
+    for setter in section.style.state_setters:
+        setter(pdf)
+
+    # Write section content — regular
+    pdf.set_font(font_family, style="", size=body_size)
+    write_params = {**section.style.write_params, "h": line_h}
+    if section.style.display == DisplayMode.BLOCK:
+        pdf.multi_cell(w=w, text=section.content, new_x=new_x, new_y="NEXT", **write_params)
+    else:
+        pdf.cell(w=w, text=section.content, **write_params)
+
+def fpdf_engine(
+    sections: list[RenderSection], 
+    layout_config: LayoutConfig,
+    output_path: str, 
+    font_face: FontFaceRule | None = None,
+    heading_config: HeadingConfig | None = None
+) -> None:
+    """Render sections to a PDF file using fpdf2."""
+    pdf = FPDF()
+    pdf.add_page()
+
+    # Register custom font or use default
+    font_family = _register_fonts(pdf, font_face)
+    pdf.set_font(font_family, size=DEFAULTS["body-font-size"])
+
+    _render_heading(pdf, heading_config, font_family)
+    if layout_config.mode == "grid":
+        _render_grid(pdf, sections, layout_config, font_family)
+    else:
+        _render_single(pdf, sections, font_family)
+
+    pdf.output(output_path)

resumeforge/mappers/heading_mapper.py

@@ -0,0 +1,23 @@
+from resumeforge.models import HeadingRule, Stylesheet, StyledHeading
+
+def map(text: str, stylesheet: Stylesheet) -> StyledHeading:
+    """Extract all text content until the first 'section' is found according to the user rcss selectors.
+    
+    This is our heading
+    """
+    
+    heading_rule: HeadingRule = stylesheet.heading
+    section_names = [s.name for s in stylesheet.sections]
+    lines = text.splitlines()
+    content_lines = []
+    for line in lines:
+        if line.strip() in section_names:
+            # we hit a section as defined in the users rcss, everything before is presumed to be the heading
+            break
+        content_lines.append(line)
+
+    content = "\n".join(content_lines).strip()
+    if not content:
+        raise ValueError("CV text must have heading content (name/contact) before the first section")
+
+    return StyledHeading(content=content, rule=heading_rule)

resumeforge/mappers/section_mapper.py

@@ -0,0 +1,92 @@
+"""Maps raw CV text sections to their corresponding RCSS style rules."""
+
+from resumeforge.models import Stylesheet, StyledSection, RawSection
+from resumeforge.validator import run_validators
+
+MAP_VALIDATORS = [
+    {
+        "check": lambda raw_sections, _: len(raw_sections) > 0,
+        "message": "No sections found in CV text matching the stylesheet. "
+                    "Ensure headings match section[name=\"...\"] values exactly.",
+    },
+    {
+        "check": lambda raw_sections, rules_by_name: set(rules_by_name.keys()) == {s.name for s in raw_sections},
+        "message": "CV text is missing one or more sections defined in the stylesheet.",
+    },
+    {
+        "check": lambda raw_sections, rules_by_name: all(s.name in rules_by_name for s in raw_sections),
+        "message": "No matching stylesheet rule for one or more sections.",
+    },
+]
+
+class SectionMapper:
+    """Splits a plain-text CV into sections and pairs each with its RCSS style rule.
+
+    A section is identified by a heading line that exactly matches a section name
+    defined in the Stylesheet (e.g. 'EXPERIENCE', 'EDUCATION', or 'John Joseph Strong').
+    Content is everything between that heading and the next heading or EOF.
+    """
+
+    def __init__(self, options: dict | None = None):
+        self._debug = options.get("debug") is True if options else False
+
+    def _log_section(self, section: tuple[str, str]):
+        """Print section heading and body when debug mode is enabled."""
+        if self._debug:
+            print(f"heading: {section[0]}\nbody: {section[1]}")
+
+    def _split_sections(self, text: str, section_names: set[str]) -> list[RawSection]:
+        """Split raw CV text into (name, content) pairs.
+
+        Walks line by line. A line whose stripped value matches a known section name
+        starts a new section. All subsequent lines (including blank lines) are captured
+        as content until the next heading or EOF.
+
+        Returns a list of (section_name, content) tuples in document order.
+        Text before the first matching heading is silently ignored.
+        """
+        sections = []
+        current_name = None
+        current_lines = []
+        current_order = 0
+
+        for line in text.splitlines():
+            # Strip only for heading comparison — raw line preserved for content
+            stripped = line.strip()
+            if stripped in section_names:
+                # New heading found — save the previous section if one was open
+                if current_name:
+                    sections.append(RawSection.fromText(current_name, current_lines, current_order))
+                    current_order += 1
+                # Start collecting for this new section
+                current_name = stripped
+                current_lines = []
+            elif current_name:
+                # Inside a section — append raw line (preserves whitespace/blank lines)
+                current_lines.append(line)
+            # else: before any heading (preamble) — silently skipped
+
+        # EOF reached — flush the last open section
+        if current_name:
+            sections.append(RawSection.fromText(current_name, current_lines, current_order))
+
+        return sections
+
+    def _apply_rules(self, raw_sections: list[RawSection], rules_by_name: dict) -> list[StyledSection]:
+        """Match each raw section to its SectionRule. Pure transformation — no validation."""
+        return [
+            StyledSection(name=s.name, content=s.content, rule=rules_by_name[s.name], order=s.order)
+            for s in raw_sections
+        ]
+        
+    def map(self, text: str, stylesheet: Stylesheet) -> list[StyledSection]:
+        """Map raw CV text to a list of StyledSection objects.
+
+        Splits the text into sections by heading, validates, then pairs each
+        section with its matching SectionRule from the stylesheet.
+        """
+        section_names = {s.name for s in stylesheet.sections}
+        rules_by_name = {rule.name: rule for rule in stylesheet.sections}
+        raw_sections = self._split_sections(text=text, section_names=section_names)
+        run_validators(MAP_VALIDATORS, raw_sections, rules_by_name)
+        return self._apply_rules(raw_sections=raw_sections, rules_by_name=rules_by_name)

resumeforge/models.py

@@ -0,0 +1,89 @@
+from dataclasses import dataclass
+
+from lark import Tree
+
+@dataclass
+class ValidationResult:
+    """A validation result used by parser.py. 
+    
+    Encapsulates the status of lark prasing of a provided RCSS text with optional user friendly message to display
+    """
+    valid: bool
+    message: str | None = None
+
+@dataclass
+class ParseResult:
+    """Result of parsing RCSS text.
+    
+    valid: whether the RCSS is syntactically correct
+    message: error description if valid is False
+    tree: the Lark parse tree if valid is True, None otherwise
+    """
+    valid: bool
+    message: str | None = None
+    tree: Tree | None = None
+
+@dataclass
+class Declaration:
+    """A single property: value pair like 'padding: 8mm'"""
+    property: str
+    values: list[str]  # list because margins has 4 values: 20mm 18mm 20mm 18mm
+  
+@dataclass
+class LayoutRule:
+    """The layout { ... } block — page-level settings"""
+    declarations: list[Declaration]
+    # Convenience: pull out mode, columns, margins etc. later via helper methods
+
+@dataclass
+class HeadingRule:
+    """The heading { } block - top level text content for Name, contact info and title"""
+    declarations: list[Declaration]
+  
+@dataclass
+class SectionRule:
+    """A section[name="..."] { ... } block — per-section styles"""
+    name: str  # the heading text, e.g. "HEADER", "WORK EXPERIENCE"
+    declarations: list[Declaration]
+
+@dataclass
+class FontFaceRule:
+    """A @font-face block"""
+    declarations: list[Declaration]
+  
+@dataclass
+class Stylesheet:
+    """The complete parsed .rcss file as domain objects"""
+    layout: LayoutRule # required — every .rcss must have a layout block
+    heading: HeadingRule | None # optional - falls-back to using ATS resonable defaults
+    sections: list[SectionRule] # required - every .rcss must have 1..N section blocks
+    font_face: FontFaceRule | None = None # optional - falls-back to default font
+
+@dataclass
+class StyledHeading:
+    """A heading with its rcss style and layout rules"""
+    content: str
+    rule: HeadingRule
+
+@dataclass
+class StyledSection:
+    """Encapsulated str content with its section rule from a Stylesheet"""
+    name: str
+    content: str
+    rule: SectionRule
+    order: int
+
+@dataclass
+class RawSection:
+    """A section extracted from raw CV text, before style rules are applied."""
+    name: str
+    content: str
+    order: int
+
+    @staticmethod
+    def fromText(name: str, content: list[str], order: int) -> 'RawSection':
+        return RawSection(
+            name=name,
+            content="\n".join(content),
+            order=order
+        )

resumeforge/parser.py

@@ -0,0 +1,39 @@
+"""Parser for RCSS DSL. Parse or Validate RCSS text"""
+
+# Lark is the parsing library that reads grammar/rcss.lark and builds a parse tree
+from lark import Lark
+from lark.exceptions import UnexpectedToken, UnexpectedCharacters
+from pathlib import Path
+
+from resumeforge.models import ValidationResult, ParseResult
+
+GRAMMAR_PATH = Path(__file__).parent / "grammar" / "rcss.lark"
+
+class RcssParser:
+    def __init__(self):
+        """Read the grammar and compile it"""
+        grammer_text = GRAMMAR_PATH.read_text()
+        self._parser = Lark(grammer_text, parser="lalr")
+
+    def validate(self, text: str):
+        "Validate a raw string against the rcss grammar."
+        try:
+            self._parser.parse(text)
+            return ValidationResult(valid = True)
+        except (UnexpectedToken, UnexpectedCharacters) as e:
+            return ValidationResult(
+                valid = False,
+                message = f"Line {e.line}, Col {e.column}: {e}"
+            )
+    
+    def parse(self, text: str, options: dict | None = None):
+        """Parse RCSS text. Validates first, returns ParseResult with tree on success."""
+        result = self.validate(text)
+        if not result.valid:
+            return ParseResult(valid=False, message=result.message)
+        tree = self._parser.parse(text)
+        if options and options.get("debug") is True:
+            # Pretty print the AST when debug mode is enabled
+            print(tree.pretty())
+        
+        return ParseResult(valid=True, tree=tree)

resumeforge/renderer.py

@@ -0,0 +1,80 @@
+"""Renders StyledSections into a paginated A4 PDF."""
+
+from dataclasses import dataclass
+from typing import Callable
+
+from resumeforge.models import FontFaceRule, LayoutRule, StyledSection, Declaration, StyledHeading
+from resumeforge.adapters.fpdf_adapter import SectionRenderStyle
+from resumeforge.adapters.layout_adapter import LayoutConfig
+from resumeforge.adapters.heading_adapter import adapt_heading
+
+# Type alias for any adapter function
+StyleAdapter = Callable[[list[Declaration]], SectionRenderStyle]
+LayoutAdapter = Callable[[LayoutRule], LayoutConfig]
+
+@dataclass
+class RenderSection:
+    """A section prepared for the engine: content paired with its adapted style."""
+    name: str
+    content: str
+    style: SectionRenderStyle
+    order: int
+    grid_column: int | None = None
+
+
+# Type alias for any render engine function
+RenderEngine = Callable[[list["RenderSection"], LayoutConfig, str, FontFaceRule | None, StyledHeading | None], None]
+
+class Renderer:
+    """Takes styled sections and a layout rule, renders to PDF.
+
+    Adapter converts RCSS declarations into rendering instructions.
+    Engine writes the adapted sections to a specific output format.
+    """
+
+    def __init__(self, adapter: StyleAdapter, engine: RenderEngine, layout_adapter: LayoutAdapter, options: dict | None = None):
+        self._debug = options.get("debug") is True if options else False
+        self._adapter = adapter
+        self._engine = engine
+        self._layout_adapter = layout_adapter
+
+    def _log(self, step: str, detail: str):
+        if self._debug:
+            print(f"[renderer:{step}] {detail}")
+
+    def render(self, 
+            sections: list[StyledSection],
+            layout: LayoutRule, 
+            output_path: str, 
+            font_face: FontFaceRule | None = None,
+            heading: StyledHeading | None = None
+        ) -> None:
+        """Render styled sections to a PDF file at output_path."""
+        self._log("start", f"rendering {len(sections)} sections to {output_path}")
+        self._log("layout", f"{layout.declarations}")
+
+        layout_config = self._layout_adapter(layout)
+        self._log("layout_config", f"{layout_config}")
+
+        heading_config = adapt_heading(heading)
+        self._log("heading_config", f"{heading_config}")
+
+        render_sections = []
+        for section in sorted(sections, key=lambda s: s.order):
+            self._log("section", f"[{section.order}] {section.name}")
+            style = self._adapter(section.rule.declarations)
+            self._log("adapted", f"{style}")
+            grid_column = next(
+                (int(d.values[0]) for d in section.rule.declarations if d.property == "grid-column"),
+                None,
+            )
+            render_sections.append(RenderSection(
+                name=section.name,
+                content=section.content,
+                style=style,
+                order=section.order,
+                grid_column=grid_column,
+            ))
+
+        self._engine(render_sections, layout_config, output_path, font_face=font_face, heading_config=heading_config)
+        self._log("done", output_path)

resumeforge/transformer.py

@@ -0,0 +1,158 @@
+"""Transforms a Lark parse tree into domain models (Stylesheet)."""
+
+from lark import Transformer, Token, Tree
+from resumeforge.models import Declaration, FontFaceRule, LayoutRule, SectionRule, Stylesheet, HeadingRule
+from resumeforge.validator import run_validators
+
+def extract_column_widths_from_layout_declarations(layout: LayoutRule) -> Declaration | None:
+    return next((d for d in layout.declarations if d.property == 'column-widths'), None)
+
+def _check_column_widths_format(layout: LayoutRule, _) -> bool:
+    """Ensure column-widths values are integer percentages."""
+    decl = extract_column_widths_from_layout_declarations(layout)
+    if decl is None:
+        return True
+    for v in decl.values:
+        if not v.endswith("%"):
+            return False
+        number = v[:-1]
+        if not number.isdigit():
+            return False
+    return True
+
+def _check_column_widths_sum(layout: LayoutRule, _) -> bool:
+    """Ensure if column_widths is set the values sum to 100%"""
+    decl = extract_column_widths_from_layout_declarations(layout)
+    if decl is None:
+        return True
+    values = [int(v.rstrip("%")) for v in decl.values]
+    return sum(values) == 100
+
+STYLESHEET_RULE_VALIDATORS = [
+    {
+        "check": lambda layout, _: layout is not None,
+        "message": "RCSS must contain a layout { ... } rule",
+    },
+    {
+        "check": _check_column_widths_format,
+        "message": "column-widths values must be whole numbers with % (e.g. \"35% 65%\")",
+    },
+    {
+        "check": _check_column_widths_sum,
+        "message": "column-widths must sum to 100%",
+    },
+    {
+        "check": lambda _, sections: len(sections) > 0,
+        "message": "RCSS must contain at least one section[name=\"...\"] rule",
+    },
+]
+
+class RcssTransformer(Transformer):
+    """Walks the parse tree bottom-up, converting nodes into domain models."""
+
+    def __init__(self, options: dict | None = None):
+        super().__init__()
+        self._debug = options.get("debug") is True if options else False
+
+    def _log(self, rule_name: str, items):
+        if self._debug:
+            print(f"[{rule_name}] {items}")
+
+    def value(self, items) -> list[str]:
+        """Extract values from TOKEN array. 
+
+        e.g. Token('VALUE', '8mm') → str(token) → "8mm"
+        """
+        self._log("value", items)
+        return [str(token) for token in items]
+
+    def declaration(self, items) -> Declaration:
+        """Extract property and values[] from TOKEN.
+        
+        e.g. Token('PROPERTY', 'padding'), ['8mm'] -> Declaration('padding', ['8mm'])
+        """
+        self._log("declaration", items)
+        return Declaration(property=str(items[0]), values=items[1])
+
+    def layout_selector(self, items) -> str:
+        """layout is a dsl selector it doesn't have any tokens"""
+        self._log("layout_selector", items)
+        return "layout"
+    
+    def heading_selector(self, items) -> str:
+        """heading is a dsl selector representing beginning of a well-formed resume. 
+        
+        e.g. 
+                Name
+            [contact info ..]
+        """
+        self._log("heading_selector", items)
+        return "heading"
+
+    def section_selector(self, items) -> str:
+        """Extract the section name, stripping quotes from the STRING token.
+
+        e.g. Token('STRING', '"HEADER"') → "HEADER"
+        """
+        self._log("section_selector", items)
+        return str(items[0]).strip('"')
+    
+    def fontface_selector(self, items) -> str:
+        """@font-face is a css-compatible dsl selector. it has no tokens.
+        
+        """
+        self._log("fontface_selector", items)
+        return "font-face"
+
+    def rule(self, items) -> LayoutRule | SectionRule:
+        """Map a selector + declarations into a LayoutRule or SectionRule.
+
+        items[0] is the selector return value ("layout" or a section name).
+        items[1:] are Declaration objects from each declaration in the block.
+        """
+        self._log("rule", items)
+        selector = items[0]
+        declarations = items[1:]
+        if selector == "layout":
+            return LayoutRule(declarations=declarations)
+        if selector == "font-face":
+            return FontFaceRule(declarations=declarations)
+        if selector == "heading":
+            return HeadingRule(declarations=declarations)
+        return SectionRule(name=selector, declarations=declarations)
+
+    def start(self, items) -> Stylesheet:
+        """Map the rules to layout and section[] Stylesheet.
+        
+        e.g.
+        [
+            LayoutRule(
+                declarations=Declaration(property='mode', values=['grid'])
+            ), 
+            SectionRule(name='"HEADER"', 
+                declarations=Declaration(property='grid-column', values=['1'])
+            )
+        ] -> StyleSheet(LayoutRule, SectionRule[])
+        """
+        self._log("start", items)
+        layout = None
+        font_face = None
+        heading = None
+        sections = []
+        for rule in items:
+            if isinstance(rule, LayoutRule):
+                layout = rule
+            elif isinstance(rule, FontFaceRule):
+                font_face = rule
+            elif isinstance(rule, HeadingRule):
+                heading = rule
+            else:
+                sections.append(rule)
+        
+        run_validators(STYLESHEET_RULE_VALIDATORS, layout, sections)
+        return Stylesheet(layout=layout, heading=heading, sections=sections, font_face=font_face)
+
+
+def transform(tree: Tree, options: dict | None = None) -> Stylesheet:
+    """Entry point: transform a Lark tree into a Stylesheet domain model."""
+    return RcssTransformer(options).transform(tree)

resumeforge/validator.py

@@ -0,0 +1,12 @@
+"""Shared validation runner for declarative rule lists."""
+
+def run_validators(validators: list[dict], *args):
+    """Run a list of validation rules. Raises ValueError on first failure.
+
+    Each validator is a dict with:
+      - check: callable that receives *args and returns True/False
+      - message: error string to surface if check fails
+    """
+    for rule in validators:
+        if not rule["check"](*args):
+            raise ValueError(rule["message"])

resumeforge-0.1.0.dist-info/METADATA

@@ -0,0 +1,330 @@
+Metadata-Version: 2.4
+Name: resumeforge
+Version: 0.1.0
+Summary: Convert plain-text CVs into styled A4 PDFs using RCSS
+Author: John Strong
+License: MIT
+Project-URL: Homepage, https://resume-forge-cli.web.app/
+Project-URL: Repository, https://github.com/JohnStrong/ResumeForge
+Project-URL: Issues, https://github.com/JohnStrong/ResumeForge/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: lark
+Requires-Dist: fpdf2
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pypdf; extra == "test"
+Dynamic: license-file
+
+# ResumeForge — README
+
+![build](https://github.com/JohnStrong/ResumeForge/actions/workflows/python-package.yml/badge.svg?branch=main)
+![coverage](https://codecov.io/gh/JohnStrong/ResumeForge/branch/main/graph/badge.svg)
+![version](https://img.shields.io/badge/version-0.1.0-blue)
+![python](https://img.shields.io/badge/python-3.12+-yellow)
+![license](https://img.shields.io/badge/license-MIT-green)
+
+> 🌐 **Website:** https://resume-forge-cli.web.app/
+
+## Table of Contents
+- [About](#about)
+- [Setup](#setup)
+- [Usage](#usage)
+  - [Troubleshooting](#troubleshooting)
+- [Testing](#testing)
+- [RCSS DSL](#rcss-dsl)
+  - [Section identification](#section-identification)
+  - [.rcss basics (MVP)](#rcss-basics-mvp)
+  - [Example .rcss snippets](#example-rcss-snippets)
+- [Contributing](#contributing)
+- [Examples](#examples)
+
+## About
+ResumeForge converts a plain UTF-8 text CV into a styled multi-page A4 PDF using a small CSS-like DSL (.rcss). Supports two layout modes: standard (single-column) and grid (2-column). MVP excludes font-face loading and decorative assets.
+
+## Setup
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -e .
+```
+
+## Usage
+
+```bash
+# Render a plain-text CV to styled PDF
+resumeforge render --input examples/resume.txt --style examples/valid.rcss --output resume.pdf
+
+# Validate an RCSS style file for syntax errors
+resumeforge validate --style examples/valid.rcss
+
+# Print CLI version
+resumeforge version
+```
+
+### Troubleshooting
+
+**"Unexpected token ... Expected one of: HEADING, LAYOUT, @font-face, SECTION"**
+Your `.rcss` file has an invalid selector. Only `layout { ... }`, `heading { ... }`, `@font-face { ... }`, and `section[name="..."] { ... }` are valid. Check for typos in the selector keyword.
+
+**"Unexpected token ... Expected one of: SEMICOLON"**
+A property declaration is missing its trailing semicolon. Every declaration must end with `;`.
+
+**"RCSS must contain a layout { ... } rule"**
+The transformer could not find a `layout` block in your `.rcss` file. Every stylesheet requires one.
+
+**"RCSS must contain at least one section[name=...] rule"**
+Your `.rcss` defines a layout but no section rules. Add at least one `section[name="..."] { ... }` block.
+
+**"No sections found in CV text matching the stylesheet"**
+The headings in your `.txt` file don't match any `section[name="..."]` values in the stylesheet. Headings must match exactly (case-sensitive, full line).
+
+**"CV text is missing one or more sections defined in the stylesheet"**
+Your `.txt` file is missing a heading that the stylesheet expects. Ensure every `section[name="..."]` in the `.rcss` has a corresponding heading line in the CV text.
+
+**"No raw sections to apply rules to"**
+The section mapper received no parsed sections to style. This typically means your CV text was empty or contained no lines matching any stylesheet section names.
+
+**"No matching stylesheet rule for one or more sections"**
+A section was parsed from the CV text but has no corresponding `section[name="..."]` rule in the stylesheet. Ensure every heading in your `.txt` file has a matching rule in the `.rcss`.
+
+**"column-widths must sum to 100%"**
+The percentage values in `column-widths` do not add up to 100. For example, `column-widths: 30% 60%;` totals 90%. Adjust so they equal 100%.
+
+**"column-widths values must be whole numbers with %"**
+Each value in `column-widths` must be an integer followed by `%`. Decimal values like `33.3%` and bare numbers like `35` are not allowed.
+
+**"layout property '...' is not valid"**
+The layout adapter encountered an unrecognised property in `layout { ... }`. Check for typos. Valid properties: `mode`, `columns`, `column-widths`, `column-gap`, `margins`, `font-family`.
+
+**"CV text must have heading content (name/contact) before the first section"**
+Your `.txt` file begins immediately with a section heading (e.g. `Skills` or `Experience`) with no name or contact information above it. Every CV must have at least one line of text before the first section — typically your full name, job title, and contact details (email, phone, LinkedIn). This heading block is rendered at the top of the PDF before any sections.
+
+## Testing
+
+```bash
+pip install pytest
+pytest
+```
+
+## RCSS DSL
+
+> Grammar definition: [`src/resumeforge/grammar/rcss.lark`](src/resumeforge/grammar/rcss.lark)
+
+### Section identification
+- A section begins at a heading line that matches the pattern ^{HEADING} (a full-line header like: LINKS, WORK EXPERIENCE, EDUCATION).
+- A section contains all text from that heading line up to the next heading line or EOF.
+- Section selectors in .rcss match the heading text exactly (e.g., section[name="WORK EXPERIENCE"]).
+
+### .rcss basics (MVP)
+- File extension: .rcss
+- Grid mode supports exactly 2 columns. grid-column must be 1 or 2 for each section in grid mode.
+
+#### Layout properties (in `layout { ... }`)
+| Property | Values | Description |
+|---|---|---|
+| `mode` | `single`, `grid` | Page layout mode |
+| `columns` | `2` | Number of columns (grid mode) |
+| `column-widths` | e.g. `35% 65%` | Width of each column as percentages (grid mode, must sum to 100%) |
+| `column-gap` | e.g. `6mm` | Gap between columns |
+| `margins` | e.g. `20mm 18mm 20mm 18mm` | Page margins (top right bottom left) |
+| `font-family` | e.g. `"Helvetica"` | Default font (overridden by @font-face) |
+
+#### Font face properties (in `@font-face { ... }`) — optional
+| Property | Values | Description |
+|---|---|---|
+| `font-family` | e.g. `"Carlito"` | Font family name to register |
+| `src` | e.g. `"fonts/Carlito-Regular.ttf"` | Path to regular weight TTF |
+| `src-bold` | e.g. `"fonts/Carlito-Bold.ttf"` | Path to bold weight TTF |
+
+#### Heading properties (in `heading { ... }`) — optional
+The `heading` block styles the resume header (name, title, contact info) that appears before the first section. If omitted, ATS-friendly defaults are applied automatically.
+
+| Property | Values | Default | Description |
+|---|---|---|---|
+| `font-size` | e.g. `20pt` | `20pt` | Name/first line font size. Subsequent lines (contact info, title) are scaled down proportionally |
+| `align` | `left`, `center`, `right` | `center` | Text alignment |
+| `line-height` | e.g. `7` | `7` | Line height in mm |
+| `color` | e.g. `#333333` | black | Text color (hex) |
+
+#### Section properties (in `section[name="..."] { ... }`)
+
+**Style properties** (PDF render mode — applied as PDF state before writing):
+| Property | Values | Default | Description |
+|---|---|---|---|
+| `font-size` | e.g. `12pt` | `11pt` | Text size |
+| `color` | e.g. `#333333` | black | Text color (hex) |
+| `background-color` | e.g. `#f0f0f0` | none | Section fill color (hex) |
+
+**Write properties** (PDF render mode — control how content is rendered):
+| Property | Values | Default | Description |
+|---|---|---|---|
+| `align` | `left`, `center`, `right` | `left` | Text alignment |
+| `line-height` | e.g. `7` | `5` | Line height in mm |
+| `display` | `block`, `inline` | `block` | Block wraps text (multi-line), inline flows horizontally |
+
+**Layout positioning** (grid mode only):
+| Property | Values | Default | Description |
+|---|---|---|---|
+| `grid-column` | `1`, `2` | — | Which column to place the section in |
+| `padding` | e.g. `8mm` | `0` | Inner spacing |
+| `width` | e.g. `1fr` | `1fr` | Proportional column width |
+
+### Example .rcss snippets
+Single-column (resume-single.rcss)
+```css
+layout { mode: single; margins: 20mm 18mm 20mm 18mm; }
+
+section[name="HEADER"] {
+  padding: 8mm;
+  align: center;
+}
+```
+
+Two-column grid (resume-grid.rcss)
+```css
+layout { mode: grid; columns: 2; column-widths: 35% 65%; column-gap: 6mm; margins: 20mm 18mm 20mm 18mm; }
+
+/* Place by heading text and explicit column (1 or 2) */
+section[name="SIDEBAR"] {
+  grid-column: 1;
+  padding: 6mm;
+  width: 1fr;
+}
+
+section[name="MAIN"] {
+  grid-column: 2;
+  padding: 6mm;
+  width: 1fr;
+}
+
+section[name="HEADER"] {
+  grid-column: 1;
+  padding: 8mm;
+  align: center;
+}
+```
+
+## Contributing
+
+1. Create a feature branch from `main`: `git checkout -b feature/your-feature`
+2. Make changes, commit using [Conventional Commits](https://www.conventionalcommits.org/) (`feat:`, `fix:`, `docs:`, `refactor:`, `test:`)
+3. Ensure all tests pass: `pytest`
+4. Open a pull request for code review before merging
+5. Merge to `main` with `--no-ff` to preserve branch history
+
+## Examples
+
+### Step 1: Write your CV as plain text (`examples/resume.txt`)
+
+```
+Lorem Ipsum
+Senior Software Engineer
+lorem.ipsum@fakeemail.xyz | +44 0000 000000
+
+Links
+github.com/loremipsum
+linkedin.com/in/loremipsum
+loremipsum.dev
+
+Skills
+- Python, 
+- TypeScript
+- Go
+- Rust
+- AWS (Lambda, DynamoDB, ECS, CDK)
+- Terraform
+- PostgreSQL, 
+- Redis, 
+- Kafka
+- System Design
+- CI/CD
+- Kubernetes
+- Observability
+
+Work Experience
+Senior Software Engineer - Acme Widget Corp
+Jan 2021 - Present
+- Architected event-driven microservices processing 2M+ events/day
+- Led monolith-to-ECS migration reducing deploy times by 70%
+- Designed real-time analytics pipeline using Kafka and Flink
+- Mentored 4 junior engineers through pairing and code review
+
+Software Engineer - Placeholder Technologies Inc
+Mar 2018 - Dec 2020
+- Built REST and gRPC APIs serving 500K daily active users
+- Implemented canary deployments reducing rollback incidents by 85%
+- Developed internal CLI tooling adopted by 3 engineering teams
+
+Software Engineer - Foobar Systems Ltd
+Sep 2015 - Feb 2018
+- Developed customer-facing dashboard using React and TypeScript
+- Designed multi-tenant SaaS schema in PostgreSQL
+- Reduced API response times by 40% through caching
+
+Education
+MSc Computer Science - University of Nowhere, 2015
+BSc Mathematics - University of Somewhere, 2013
+
+References
+Dolor Sit Amet
+Engineering Director, Acme Widget Corp
+dolor.sit@fakecorp.xyz
+
+Consectetur Adipiscing
+CTO, Placeholder Technologies Inc
+consectetur@faketech.xyz
+```
+
+### Step 2: Style it with RCSS (`examples/valid.rcss`)
+
+```css
+@font-face { font-family: "Carlito"; src: "examples/fonts/Carlito-Regular.ttf"; src-bold: "examples/fonts/Carlito-Bold.ttf"; }
+
+layout { mode: grid; columns: 2; column-widths: 30% 70%; column-gap: 6mm; margins: 20mm 18mm 20mm 18mm; font-family: "Carlito"; }
+
+heading { font-size: 20pt; align: center; line-height: 7; color: #555555; }
+
+section[name="Links"] {
+  color: #336699;
+  line-height: 5;
+  grid-column: 1;
+}
+
+section[name="Skills"] {
+  line-height: 5;
+  grid-column: 1;
+}
+
+section[name="Work Experience"] {
+  line-height: 5;
+  grid-column: 2;
+}
+
+section[name="Education"] {
+  line-height: 5;
+  grid-column: 2;
+}
+
+section[name="References"] {
+  color: #555555;
+  line-height: 5;
+  grid-column: 2;
+}
+```
+
+### Step 3: Render to PDF
+
+```bash
+resumeforge render --input examples/resume.txt --style examples/valid.rcss --output examples/resume.pdf
+```
+
+### Result
+
+![Resume PDF output](docs/resume.png)

resumeforge-0.1.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+resumeforge/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+resumeforge/cli.py,sha256=lCstEc2wSt5QgrbctNuWVMPwUnBdauqsw5WyWDKINzs,3855
+resumeforge/constants.py,sha256=RZnLATxGbTy0E4oWvQ82HZ2K3iodmEZVW1hNgfNzt-A,507
+resumeforge/models.py,sha256=Xw4DVUQXbBUukEok_g_050IQKNoDAsHElrVqr5x14lM,2596
+resumeforge/parser.py,sha256=uj3pnvGBhFWXMgSBV_vLD3OYbJh_XHzJHiKoc4X6-sM,1510
+resumeforge/renderer.py,sha256=ybybsbrQhPap0tN_p21TzBxY_rAzQ0_3cYBrdUN92QE,3123
+resumeforge/transformer.py,sha256=qxSGqjOgkBV29DfPAUOhMKps8F_dqkuDuMH784RecQ8,5676
+resumeforge/validator.py,sha256=QSgY4yfey-0p8ylt87mv-wJkHL9cqT4x9lZVAZ5m3Vw,464
+resumeforge/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+resumeforge/adapters/fpdf_adapter.py,sha256=Hdx9E-UB0zLi3HT3BURR9J9HNnfYbYTUgc22-tEhnug,2353
+resumeforge/adapters/heading_adapter.py,sha256=0X27-N32vt9F67sH9u8wFigfy_Nowgb3quGY4ekW43Y,1390
+resumeforge/adapters/layout_adapter.py,sha256=-4WPZENwvnD_h-SrF5k7InJ5c1IMpDhCW4ETgjQ-F3c,1239
+resumeforge/engines/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+resumeforge/engines/fpdf_engine.py,sha256=zt_t8zcPV2j4JAUnaud4zBA_JD1YkemaCs036z6K5lc,6208
+resumeforge/mappers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+resumeforge/mappers/heading_mapper.py,sha256=krRwv3mQncPt-JuhFwtJhX4fIwGNCa-2dc6ArMsQMLI,900
+resumeforge/mappers/section_mapper.py,sha256=IxejGJcXOy7sSkGoq3_jZtWIo3mzqu4kDJ23FtKDJCs,4260
+resumeforge-0.1.0.dist-info/licenses/LICENSE,sha256=hM-V-L3JzXZRUcJ7bCHfEW7VQFjPeW-TS-9qNRW4lUc,1075
+resumeforge-0.1.0.dist-info/METADATA,sha256=LAdcjQQvLeasTessmpKUKoWY4JU8hGUqFyxWzj9rlMQ,11627
+resumeforge-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+resumeforge-0.1.0.dist-info/entry_points.txt,sha256=zOHEG0Y1URrsCb_7Z1zrjhLdI5lBMgWwIdKEPtkcSPM,53
+resumeforge-0.1.0.dist-info/top_level.txt,sha256=Ma7VdYjmANdBuQVfC2fUGA8unCFtltFe70qizuH8m8Q,12
+resumeforge-0.1.0.dist-info/RECORD,,

resumeforge-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

resumeforge-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+resumeforge = resumeforge.cli:main

resumeforge-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 John Joseph Strong
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

resumeforge-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+resumeforge