PyPI - clawed - Versions diffs - 2.5.1__tar.gz → 2.5.2__tar.gz - Mend

clawed 2.5.1tar.gz → 2.5.2tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (257) hide show

{clawed-2.5.1 → clawed-2.5.2}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clawed
-Version: 2.5.1
+Version: 2.5.2
 Summary: Free AI lesson planner for teachers. Learns your teaching voice from your curriculum files and generates complete lesson packages. Open source, runs locally, no subscription.
 Project-URL: Homepage, https://sirhanmacx.github.io/Claw-ED
 Project-URL: Documentation, https://github.com/SirhanMacx/Claw-ED#readme

{clawed-2.5.1 → clawed-2.5.2}/clawed/__init__.py RENAMED Viewed

@@ -17,7 +17,7 @@ if hasattr(sys.stderr, "reconfigure"):
     except Exception:
         pass
-__version__ = "2.5.1"
+__version__ = "2.5.2"
 __author__ = "Jon Maccarello & Claw-ED contributors"
 __description__ = "Personal AI teaching agent. Learns your voice, works while you sleep."

{clawed-2.5.1 → clawed-2.5.2}/clawed/commands/generate.py RENAMED Viewed

@@ -306,7 +306,10 @@ def lesson(
         False, "--game/--no-game",
         help="Also generate an interactive HTML learning game",
     ),
-    fmt: str = typer.Option("markdown", "--format", "-f", help="Export format: markdown, pptx, docx, pdf, handout"),
+    fmt: str = typer.Option(
+        "handout", "--format", "-f",
+        help="Export: handout, docx, pptx, pdf, markdown",
+    ),
 ):
     """Generate a detailed daily lesson plan.
@@ -408,13 +411,14 @@ def lesson(
                 from clawed.compile_teacher import compile_teacher_view
                 from clawed.multi_agent import multi_agent_generate_master_content
                 console.print("[dim]Using multi-agent pipeline (researcher→writer→reviewer)...[/dim]")
+                _ma_config = AppConfig.load()
                 master = _run_async(
                     multi_agent_generate_master_content(
                         topic=topic,
                         grade=grade,
                         subject=subject,
                         persona=persona,
-                        config=None,
+                        config=_ma_config,
                         unit_context=kb_prompt_section,
                     )
                 )

{clawed-2.5.1 → clawed-2.5.2}/clawed/compile_game.py RENAMED Viewed

@@ -20,6 +20,7 @@ from __future__ import annotations
 import logging
 import re
 from pathlib import Path
+from typing import Any
 from clawed.io import safe_filename
 from clawed.llm import LLMClient
@@ -36,6 +37,11 @@ mechanic, different visual style, different interaction pattern.
 RULES:
 - Output ONLY the complete HTML file. No explanation, no markdown fencing.
+- The file MUST start with <!DOCTYPE html> then <html>, then <head>, then <body>. \
+Always use this exact structure — never put CSS or text directly inside <html> \
+without a <head> or <body> wrapper.
+- The <head> MUST contain: <meta charset="UTF-8">, a <title> tag, and a <style> block.
+- The <body> contains all visible elements and <script> tags.
 - The file must be self-contained: all CSS and JS inline.
 - You may use a Three.js CDN link for 3D: \
 <script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r128/three.min.js"></script>
@@ -59,12 +65,15 @@ WHAT MAKES A GREAT LEARNING GAME:
 def _extract_game_content(master: MasterContent) -> str:
-    """Extract educational content from MasterContent for game generation."""
+    """Extract educational content from MasterContent for game generation.
+    Accepts MasterContent or DailyLesson (single-agent path lacks subject/grade_level).
+    """
     parts = [
         f"LESSON: {master.title}",
-        f"SUBJECT: {master.subject}",
-        f"GRADE: {master.grade_level}",
-        f"TOPIC: {master.topic}",
+        f"SUBJECT: {getattr(master, 'subject', 'Social Studies')}",
+        f"GRADE: {getattr(master, 'grade_level', '')}",
+        f"TOPIC: {getattr(master, 'topic', master.title)}",
         f"OBJECTIVE: {master.objective}",
     ]
@@ -76,36 +85,187 @@ def _extract_game_content(master: MasterContent) -> str:
                 + (f" (context: {v.context_sentence})" if v.context_sentence else "")
             )
-    if master.guided_notes:
+    guided_notes = getattr(master, "guided_notes", None)
+    if guided_notes:
         parts.append("\nKEY FACTS (fill-in-the-blank):")
-        for note in master.guided_notes:
+        for note in guided_notes:
             parts.append(f"  - Q: {note.prompt} → A: {note.answer}")
-    if master.exit_ticket:
+    exit_ticket = getattr(master, "exit_ticket", None)
+    if exit_ticket:
         parts.append("\nQUIZ QUESTIONS:")
-        for i, q in enumerate(master.exit_ticket, 1):
-            parts.append(f"  {i}. {q.question}")
+        # DailyLesson exit_ticket is a list of ExitTicketQuestion (has .question)
+        # MasterContent exit_ticket may differ — handle both
+        for i, q in enumerate(exit_ticket if isinstance(exit_ticket, list) else [], 1):
+            question_text = getattr(q, "question", str(q))
+            parts.append(f"  {i}. {question_text}")
             if hasattr(q, "expected_answer") and q.expected_answer:
                 parts.append(f"     Answer: {q.expected_answer}")
-    if master.primary_sources:
+    primary_sources = getattr(master, "primary_sources", None)
+    if primary_sources:
         parts.append("\nPRIMARY SOURCES:")
-        for src in master.primary_sources:
-            parts.append(f"  - {src.title} ({src.source_type})")
+        for src in primary_sources:
+            src_title = getattr(src, "title", str(src))
+            src_type = getattr(src, "source_type", "")
+            parts.append(f"  - {src_title} ({src_type})")
             if hasattr(src, "content_text") and src.content_text:
                 parts.append(f"    Text: {src.content_text[:300]}...")
-    if master.direct_instruction:
+    direct_instruction = getattr(master, "direct_instruction", None)
+    if direct_instruction and not isinstance(direct_instruction, str):
         parts.append("\nKEY CONCEPTS:")
-        for section in master.direct_instruction:
-            parts.append(f"  - {section.heading}")
+        for section in direct_instruction:
+            parts.append(f"  - {getattr(section, 'heading', str(section))}")
             if hasattr(section, "key_points") and section.key_points:
                 for pt in section.key_points[:3]:
                     parts.append(f"    • {pt}")
+    elif isinstance(direct_instruction, str) and direct_instruction:
+        parts.append(f"\nKEY CONCEPTS:\n{direct_instruction[:500]}")
     return "\n".join(parts)
+def _repair_html_structure(html: str) -> str:
+    """Repair common LLM HTML generation failures.
+    LLMs sometimes emit:
+    - CSS rules directly after <!DOCTYPE html> with no <head> or <body>
+    - <title> text as bare text instead of inside a <title> tag
+    - <style> content without the wrapping <style> tag
+    - Missing </html> closer
+    This function detects those patterns and wraps the content into a
+    valid HTML skeleton, preserving all the CSS and JS the LLM generated.
+    """
+    html_lower = html.lower()
+    # Strip duplicate DOCTYPE/html tags (LLM sometimes nests two documents)
+    if html.count("<!DOCTYPE") > 1:
+        # Keep only the content between the LAST <!DOCTYPE and end
+        # Actually: strip all but the first DOCTYPE
+        parts = html.split("<!DOCTYPE")
+        html = "<!DOCTYPE" + parts[1]  # keep first occurrence + content
+        for extra in parts[2:]:
+            # Append content after stripping the duplicate preamble
+            extra_content = re.sub(
+                r"^[^>]*>\s*<html[^>]*>\s*", "", extra, flags=re.IGNORECASE
+            )
+            html += extra_content
+        html_lower = html.lower()
+    # Check for bare JS not wrapped in <script> tags
+    has_script_tags = "<script" in html_lower
+    has_js_code = bool(re.search(
+        r"(?:function\s+\w+|const\s+\w+\s*=|let\s+\w+\s*=|document\.|addEventListener)",
+        html
+    ))
+    if not has_script_tags and has_js_code:
+        # Find where JS starts (after the last </div> or after CSS)
+        # Look for first function/const/let/document line
+        js_start = re.search(
+            r"\n((?:function |const |let |var |document\.|//\s*[-=]|class\s+\w+\s*\{))",
+            html
+        )
+        if js_start:
+            before_js = html[:js_start.start()]
+            js_code = html[js_start.start():]
+            # Strip trailing </body></html> from JS if present
+            js_code = re.sub(r"\s*</body>\s*</html>\s*$", "", js_code, flags=re.IGNORECASE)
+            html = before_js + "\n<script>\n" + js_code + "\n</script>\n</body>\n</html>"
+            html_lower = html.lower()
+    # Already well-formed — has <head>, <body>, and <script>
+    if "<head>" in html_lower and "<body>" in html_lower and (has_script_tags or "<script" in html_lower):
+        return html
+    # Has <head> but no <body> — unusual, leave it
+    if "<head>" in html_lower:
+        return html
+    # Missing <head>/<body> — LLM dumped CSS/JS straight into <html>
+    # Strategy: find the first <script or first element tag to split on,
+    # put everything before the first block element into <head>,
+    # everything else into <body>.
+    # Collect lines after <!DOCTYPE html><html ...>
+    # Find where the html tag ends
+    html_tag_end = html_lower.find(">", html_lower.find("<html"))
+    if html_tag_end == -1:
+        # No <html> tag at all — wrap everything
+        title_match = re.search(r"^([^\n<@{]+)", html.strip())
+        title_text = title_match.group(1).strip() if title_match else "Learning Game"
+        return (
+            f"<!DOCTYPE html>\n<html lang=\"en\">\n<head>\n"
+            f"<meta charset=\"UTF-8\">\n"
+            f"<meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">\n"
+            f"<title>{title_text}</title>\n"
+            f"<style>\n{html}\n</style>\n</head>\n<body></body>\n</html>"
+        )
+    _preamble = html[:html_tag_end + 1]  # noqa: F841  # everything up to and including <html ...>
+    rest = html[html_tag_end + 1:].strip()
+    # Extract bare title text (first non-tag, non-CSS line after <html>)
+    # This catches lines like "Age of Exploration: Chart Your Course" emitted before the CSS
+    title_text = "Learning Game"
+    title_match = re.match(r"^\s*([A-Za-z][^\n@{<]{3,120})\n", rest)
+    if title_match:
+        candidate = title_match.group(1).strip()
+        # Accept as title if it looks like a human-readable title (not CSS)
+        if not candidate.startswith(("@", "{", ".", "#", "*", ":", "/")):
+            title_text = candidate
+            rest = rest[title_match.end():]
+    # Split: CSS/meta goes in <head>, script/div/etc goes in <body>
+    head_parts: list[str] = []
+    body_parts: list[str] = []  # noqa: F841
+    # Collect <meta> tags floating outside <head>
+    meta_tags = re.findall(r"<meta[^>]*>", rest, re.IGNORECASE)
+    for m in meta_tags:
+        head_parts.append(m)
+        rest = rest.replace(m, "", 1)
+    # Wrap bare CSS (starts with @import, :root, or selector{) in <style>
+    # Find contiguous CSS blocks before the first <script or <div
+    first_script = re.search(r"<script|<div|<section|<main|<canvas", rest, re.IGNORECASE)
+    split_at = first_script.start() if first_script else len(rest)
+    css_block = rest[:split_at].strip()
+    body_block = rest[split_at:].strip()
+    if css_block:
+        # Check if it's raw CSS (no surrounding <style> tags)
+        if not re.search(r"<style", css_block, re.IGNORECASE):
+            head_parts.append(f"<style>\n{css_block}\n</style>")
+        else:
+            head_parts.append(css_block)
+    head_html = "\n".join(head_parts)
+    body_html = body_block
+    # Ensure </html> at end
+    if not body_html.rstrip().endswith("</html>"):
+        body_html = body_html.rstrip()
+        if not body_html.endswith("</body>"):
+            body_html += "\n</body>"
+        body_html += "\n</html>"
+    repaired = (
+        f"<!DOCTYPE html>\n<html lang=\"en\">\n<head>\n"
+        f"<meta charset=\"UTF-8\">\n"
+        f"<meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0, user-scalable=no\">\n"
+        f"<title>{title_text}</title>\n"
+        f"{head_html}\n"
+        f"</head>\n<body>\n"
+        f"{body_html}"
+    )
+    logger.info("Repaired HTML structure (was missing <head>/<body>)")
+    return repaired
 def _validate_game_html(html: str, master: MasterContent) -> list[str]:
     """Validate that the generated HTML is a working game."""
     issues = []
@@ -116,6 +276,12 @@ def _validate_game_html(html: str, master: MasterContent) -> list[str]:
     if "<html" not in html.lower():
         issues.append("Missing <html> tag")
+    if "<head>" not in html.lower():
+        issues.append("Missing <head> tag — CSS may render broken")
+    if "<body>" not in html.lower():
+        issues.append("Missing <body> tag — content structure invalid")
     if "<script" not in html.lower():
         issues.append("Missing <script> tag — no JavaScript")
@@ -123,7 +289,7 @@ def _validate_game_html(html: str, master: MasterContent) -> list[str]:
         issues.append("No JavaScript functions found")
     # Check that educational content is embedded
-    topic_words = master.topic.lower().split()[:3]
+    topic_words = getattr(master, "topic", master.title).lower().split()[:3]
     html_lower = html.lower()
     found_topic = any(w in html_lower for w in topic_words if len(w) > 3)
     if not found_topic:
@@ -142,7 +308,7 @@ def _validate_game_html(html: str, master: MasterContent) -> list[str]:
 async def compile_game(
-    master: MasterContent,
+    master: "MasterContent | Any",
     persona: TeacherPersona | None = None,
     output_dir: Path | None = None,
     config: AppConfig | None = None,
@@ -172,7 +338,15 @@ async def compile_game(
     output_dir.mkdir(parents=True, exist_ok=True)
     config = config or AppConfig.load()
-    config = route_model("game_generate", config)
+    # Games require maximum intelligence — always Opus.
+    from clawed.config import get_api_key
+    from clawed.models import LLMProvider
+    anthropic_key = get_api_key("anthropic")
+    if anthropic_key:
+        config.provider = LLMProvider.ANTHROPIC
+        config.anthropic_model = "claude-opus-4-6"
+    else:
+        config = route_model("game_generate", config)
     client = LLMClient(config)
     # Build the game generation prompt
@@ -209,7 +383,7 @@ async def compile_game(
     if persona:
         prompt_parts.append(
             f"\nTEACHER'S STYLE: {persona.tone or 'engaging'}\n"
-            f"Grade level: {master.grade_level}\n"
+            f"Grade level: {getattr(master, 'grade_level', '')}\n"
             "Match the difficulty and humor to this teacher and grade."
         )
@@ -233,6 +407,10 @@ async def compile_game(
                 html = re.sub(r"\n?```$", "", html)
             html = html.strip()
+            # Structural repair: LLMs sometimes emit CSS/content outside <head>/<body>.
+            # Detect and wrap into a valid HTML skeleton if needed.
+            html = _repair_html_structure(html)
             # Validate
             issues = _validate_game_html(html, master)
             if issues and attempt < max_attempts - 1:

{clawed-2.5.1 → clawed-2.5.2}/clawed/export_docx.py RENAMED Viewed

@@ -457,6 +457,8 @@ def export_student_handout(
     Returns the path to the saved .docx file.
     """
+    import re as _re
     from docx import Document
     from docx.enum.table import WD_TABLE_ALIGNMENT
     from docx.enum.text import WD_ALIGN_PARAGRAPH
@@ -464,15 +466,27 @@ def export_student_handout(
     from clawed.sanitize import sanitize_text
+    def _strip_answers(text: str) -> str:
+        """Remove answer keys from student-facing content."""
+        # Strip (Answer: ...) patterns
+        text = _re.sub(r"\s*\(Answer:\s*[^)]*\)", "", text)
+        # Strip (answer: ...) lowercase variant
+        text = _re.sub(r"\s*\(answer:\s*[^)]*\)", "", text)
+        # Strip "Answer: ..." at end of lines
+        text = _re.sub(r"\s*Answer:\s*.+$", "", text, flags=_re.MULTILINE)
+        # Strip "Expected: ..." patterns
+        text = _re.sub(r"\s*\*?Expected:?\*?\s*.+$", "", text, flags=_re.MULTILINE)
+        return text.strip()
     doc = Document()
-    # Sanitize all lesson text fields for the handout
+    # Sanitize AND strip answers from all student-facing text
     lesson.title = sanitize_text(lesson.title)
     lesson.objective = sanitize_text(lesson.objective)
     lesson.do_now = sanitize_text(lesson.do_now) if lesson.do_now else ""
     lesson.direct_instruction = sanitize_text(lesson.direct_instruction) if lesson.direct_instruction else ""
-    lesson.guided_practice = sanitize_text(lesson.guided_practice) if lesson.guided_practice else ""
-    lesson.independent_work = sanitize_text(lesson.independent_work) if lesson.independent_work else ""
+    lesson.guided_practice = _strip_answers(sanitize_text(lesson.guided_practice)) if lesson.guided_practice else ""
+    lesson.independent_work = _strip_answers(sanitize_text(lesson.independent_work)) if lesson.independent_work else ""
     for q in lesson.exit_ticket:
         q.question = sanitize_text(q.question)

clawed 2.5.1__tar.gz → 2.5.2__tar.gz

clawed 2.5.1tar.gz → 2.5.2tar.gz