clawed 2.1.0__tar.gz → 2.3.0__tar.gz

{clawed-2.1.0 → clawed-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clawed
-Version: 2.1.0
+Version: 2.3.0
 Summary: Claw-ED — personal AI teaching agent. Learns your voice, works while you sleep.
 Project-URL: Homepage, https://github.com/SirhanMacx/Claw-ED
 Project-URL: Documentation, https://github.com/SirhanMacx/Claw-ED#readme
@@ -79,15 +79,17 @@ Built on the OpenClaw agent framework. Open source. MIT license.
 
 ---
 
-## What's new in v2.0
+## What's new in v2.3
 
-**Clean output.** Zero XML tags, zero markdown artifacts, zero `<teacher prompt>` gibberish in your printed documents. Every text field in every export (DOCX, PPTX, handout) passes through a rewritten sanitization pipeline that strips LLM formatting artifacts before they reach the page.
+**Three documents, not one.** Every lesson now generates three professional files in parallel:
 
-**Your voice, for real.** The lesson generation LLM now receives your full persona, your SOUL.md, and up to 2000 characters of your voice sample in the system prompt. Lessons actually sound like you wrote them -- not a generic "expert lesson plan writer."
+1. **Student Packet** (4-6 page DOCX workbook) — Fill-in-the-blank guided notes, station sections with full primary source text and analysis questions, graphic organizer tables, exit ticket with sentence starters. This is what students hold in their hands.
+2. **Admin Lesson Plan** (observation-ready DOCX) — Multi-column table with per-section teacher actions (scripted language), student actions, observer look-fors, and differentiation. Anticipated student responses and misconceptions with teacher corrections. Teacher content knowledge appendix.
+3. **Slideshow** (PPTX) — Subject-themed slides with academic images from your own files first, then Library of Congress and Wikimedia. Vocabulary, source quotes, and section dividers on dedicated slides.
 
-**Your files matter.** When you say "make me a lesson on absolutism," the agent searches your knowledge base, finds your existing materials, and injects them as structured context into the generation prompt. The LLM sees your prior work and builds on it instead of starting from scratch.
+**Your files are first-class.** Ingestion extracts images from your PPTX/DOCX files, catalogues YouTube links, and classifies every file by type. The agent tells you what you already have before generating.
 
-**Images on by default.** Slideshows now include academic images (Library of Congress, Wikimedia) without needing `--images`. Logging added to diagnose fetch failures.
+**Pedagogical fingerprint.** "Teacher voice" means how you teach, not just how you sound. The persona captures source types, activity patterns, scaffolding moves, Do Now style, exit ticket format, and signature moves.
 
 ---
 

{clawed-2.1.0 → clawed-2.3.0}/README.md

@@ -13,15 +13,17 @@ Built on the OpenClaw agent framework. Open source. MIT license.
 
 ---
 
-## What's new in v2.0
+## What's new in v2.3
 
-**Clean output.** Zero XML tags, zero markdown artifacts, zero `<teacher prompt>` gibberish in your printed documents. Every text field in every export (DOCX, PPTX, handout) passes through a rewritten sanitization pipeline that strips LLM formatting artifacts before they reach the page.
+**Three documents, not one.** Every lesson now generates three professional files in parallel:
 
-**Your voice, for real.** The lesson generation LLM now receives your full persona, your SOUL.md, and up to 2000 characters of your voice sample in the system prompt. Lessons actually sound like you wrote them -- not a generic "expert lesson plan writer."
+1. **Student Packet** (4-6 page DOCX workbook) — Fill-in-the-blank guided notes, station sections with full primary source text and analysis questions, graphic organizer tables, exit ticket with sentence starters. This is what students hold in their hands.
+2. **Admin Lesson Plan** (observation-ready DOCX) — Multi-column table with per-section teacher actions (scripted language), student actions, observer look-fors, and differentiation. Anticipated student responses and misconceptions with teacher corrections. Teacher content knowledge appendix.
+3. **Slideshow** (PPTX) — Subject-themed slides with academic images from your own files first, then Library of Congress and Wikimedia. Vocabulary, source quotes, and section dividers on dedicated slides.
 
-**Your files matter.** When you say "make me a lesson on absolutism," the agent searches your knowledge base, finds your existing materials, and injects them as structured context into the generation prompt. The LLM sees your prior work and builds on it instead of starting from scratch.
+**Your files are first-class.** Ingestion extracts images from your PPTX/DOCX files, catalogues YouTube links, and classifies every file by type. The agent tells you what you already have before generating.
 
-**Images on by default.** Slideshows now include academic images (Library of Congress, Wikimedia) without needing `--images`. Logging added to diagnose fetch failures.
+**Pedagogical fingerprint.** "Teacher voice" means how you teach, not just how you sound. The persona captures source types, activity patterns, scaffolding moves, Do Now style, exit ticket format, and signature moves.
 
 ---
 

{clawed-2.1.0 → clawed-2.3.0}/clawed/__init__.py

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

{clawed-2.1.0 → clawed-2.3.0}/clawed/agent_core/core.py

@@ -361,7 +361,18 @@ class Gateway:
             soul_context=soul_context,
         )
 
-        # 2c. Enhance prompt for multi-step planning requests
+        # 2c. Cross-session context threading — greet with continuity
+        last_session = memory_ctx.get("last_session_summary", "")
+        if last_session and not session_history:
+            system += (
+                "\n\n=== Last Session Context ===\n"
+                f"The teacher's last interaction was about: {last_session}\n"
+                "If this is a new conversation, greet them with continuity — e.g. "
+                '"Last time we worked on [topic]. Want to continue or start something new?"\n'
+                "=== End Last Session Context ===\n"
+            )
+
+        # 2d. Enhance prompt for multi-step planning requests
         from clawed.agent_core.planner import build_planning_prompt, is_planning_request
 
         if is_planning_request(message):
@@ -415,6 +426,14 @@ class Gateway:
         except Exception:
             pass
 
+        # 8. Maybe compress old episodes (runs every COMPRESSION_THRESHOLD episodes)
+        try:
+            from clawed.memory_engine import maybe_compress_episodes
+
+            maybe_compress_episodes(teacher_id)
+        except Exception:
+            pass
+
         return result
 
     # ------------------------------------------------------------------

{clawed-2.1.0 → clawed-2.3.0}/clawed/agent_core/memory/episodes.py

@@ -96,3 +96,53 @@ class EpisodicMemory:
 
         scored.sort(key=lambda x: x["similarity"], reverse=True)
         return scored[:top_k]
+
+    def get_latest_episode(self, teacher_id: str) -> dict[str, Any] | None:
+        """Return the most recent episode for a teacher, or None."""
+        with sqlite3.connect(self._db_path) as conn:
+            conn.row_factory = sqlite3.Row
+            row = conn.execute(
+                "SELECT text, metadata, created_at FROM episodes "
+                "WHERE teacher_id = ? ORDER BY created_at DESC LIMIT 1",
+                (teacher_id,),
+            ).fetchone()
+        if not row:
+            return None
+        return {
+            "text": row["text"],
+            "metadata": json.loads(row["metadata"]),
+            "created_at": row["created_at"],
+        }
+
+    def count_episodes(self, teacher_id: str) -> int:
+        """Return the total number of episodes stored for a teacher."""
+        with sqlite3.connect(self._db_path) as conn:
+            row = conn.execute(
+                "SELECT COUNT(*) FROM episodes WHERE teacher_id = ?",
+                (teacher_id,),
+            ).fetchone()
+        return row[0] if row else 0
+
+    def get_all_episodes(
+        self,
+        teacher_id: str,
+        limit: int = 500,
+        offset: int = 0,
+    ) -> list[dict[str, Any]]:
+        """Return episodes in chronological order (oldest first)."""
+        with sqlite3.connect(self._db_path) as conn:
+            conn.row_factory = sqlite3.Row
+            rows = conn.execute(
+                "SELECT text, metadata, created_at FROM episodes "
+                "WHERE teacher_id = ? ORDER BY created_at ASC "
+                "LIMIT ? OFFSET ?",
+                (teacher_id, limit, offset),
+            ).fetchall()
+        return [
+            {
+                "text": row["text"],
+                "metadata": json.loads(row["metadata"]),
+                "created_at": row["created_at"],
+            }
+            for row in rows
+        ]

{clawed-2.1.0 → clawed-2.3.0}/clawed/agent_core/memory/loader.py

@@ -96,6 +96,28 @@ def load_memory_context(teacher_id: str, current_message: str) -> dict[str, Any]
     except Exception as e:
         logger.debug("Curriculum KB search failed: %s", e)
 
+    # Layer 6: Last session summary (cross-session context threading)
+    last_session_summary = ""
+    try:
+        from clawed.agent_core.memory.episodes import EpisodicMemory
+
+        mem = EpisodicMemory()
+        latest = mem.get_latest_episode(teacher_id)
+        if latest:
+            text = latest["text"]
+            # Extract teacher's message (first line is usually "Teacher: <msg>")
+            first_line = text.split("\n")[0].strip()
+            if first_line.startswith("Teacher: "):
+                topic = first_line[len("Teacher: "):]
+            else:
+                topic = first_line
+            # Truncate to a concise summary
+            if len(topic) > 150:
+                topic = topic[:147] + "..."
+            last_session_summary = topic
+    except Exception as e:
+        logger.debug("Last session summary load failed: %s", e)
+
     return {
         "identity_summary": identity_summary,
         "curriculum_summary": curriculum_summary,
@@ -104,4 +126,5 @@ def load_memory_context(teacher_id: str, current_message: str) -> dict[str, Any]
         "preferences_summary": preferences_summary,
         "autonomy_summary": autonomy_summary,
         "curriculum_kb_context": curriculum_kb_context,
+        "last_session_summary": last_session_summary,
     }

{clawed-2.1.0 → clawed-2.3.0}/clawed/agent_core/tools/generate_lesson_bundle.py

@@ -104,18 +104,32 @@ class GenerateLessonBundleTool:
             topic=topic,
         )
 
-        # ── Search curriculum KB for relevant prior work ───────────────
+        # ── Search for teacher's existing materials (assets + KB) ─────
         kb_context = ""
         kb_prompt_section = ""
+
+        # Asset-level search (complete files, YouTube links)
+        try:
+            from clawed.asset_registry import AssetRegistry
+            registry = AssetRegistry()
+            assets = registry.search_assets(context.teacher_id, topic, top_k=5)
+            yt_links = registry.get_youtube_links(context.teacher_id, topic, top_k=3)
+            if assets or yt_links:
+                kb_prompt_section = registry.format_asset_summary(assets, yt_links)
+                logger.info(
+                    "Asset search found %d files, %d YouTube links for '%s'",
+                    len(assets), len(yt_links), topic,
+                )
+        except Exception as e:
+            logger.debug("Asset search failed: %s", e)
+
+        # KB chunk-level search (text excerpts)
         try:
             from clawed.agent_core.memory.curriculum_kb import CurriculumKB
             kb = CurriculumKB()
             kb_results = kb.search(context.teacher_id, topic, top_k=3)
             if kb_results:
-                kb_parts = []
-                for r in kb_results:
-                    if r.get("similarity", 0) > 0.1:
-                        kb_parts.append(r)
+                kb_parts = [r for r in kb_results if r.get("similarity", 0) > 0.1]
                 if kb_parts:
                     kb_context = (
                         "\n\nRelevant materials from the teacher's files:\n"
@@ -124,20 +138,22 @@ class GenerateLessonBundleTool:
                             for r in kb_parts
                         )
                     )
-                    # Build structured prompt section for the LLM
-                    kb_prompt_section = (
-                        "Teacher's Existing Materials on This Topic\n"
-                        "The teacher has created content on this topic before. "
-                        "Reference and build on their existing work:\n\n"
-                        + "\n\n".join(
-                            f"From \"{r['doc_title']}\":\n{r['chunk_text'][:500]}"
-                            for r in kb_parts
-                        )
-                        + "\n\nUse these materials as a foundation. Reference the teacher's existing "
-                        "lessons, reuse their graphic organizer formats, build on their approach. "
-                        "If the teacher has taught this topic before, extend their work — don't "
-                        "start from scratch."
+                    chunk_section = "\n\n".join(
+                        f"From \"{r['doc_title']}\":\n{r['chunk_text'][:500]}"
+                        for r in kb_parts
                     )
+                    if kb_prompt_section:
+                        kb_prompt_section += "\n\n" + chunk_section
+                    else:
+                        kb_prompt_section = (
+                            "Teacher's Existing Materials on This Topic\n"
+                            "The teacher has created content on this topic before. "
+                            "Reference and build on their existing work:\n\n"
+                            + chunk_section
+                            + "\n\nUse these materials as a foundation. "
+                            "Reference the teacher's existing lessons, reuse their "
+                            "graphic organizer formats, build on their approach."
+                        )
                     logger.info("KB search found %d relevant chunks for '%s'", len(kb_parts), topic)
         except Exception as e:
             logger.debug("KB search failed: %s", e)
@@ -216,6 +232,44 @@ class GenerateLessonBundleTool:
         except Exception:
             pass  # Review is best-effort, don't block on failure
 
+        # ── Generate student packet + admin plan in parallel ──────────
+        import asyncio
+
+        from clawed.llm import LLMClient
+
+        llm_client = LLMClient(config)
+        persona_ctx = persona.to_prompt_context()
+        student_packet = None
+        admin_plan = None
+
+        async def _gen_packet():
+            return await llm_client.generate_student_packet(
+                lesson_json_str, persona_context=persona_ctx,
+            )
+
+        async def _gen_admin():
+            return await llm_client.generate_admin_plan(
+                lesson_json_str, persona_context=persona_ctx,
+            )
+
+        try:
+            results = await asyncio.gather(
+                _gen_packet(), _gen_admin(), return_exceptions=True,
+            )
+            if not isinstance(results[0], Exception):
+                student_packet = results[0]
+                logger.info("Student packet generated: %d stations, %d guided notes",
+                            len(student_packet.stations), len(student_packet.guided_notes))
+            else:
+                logger.warning("Student packet generation failed: %s", results[0])
+            if not isinstance(results[1], Exception):
+                admin_plan = results[1]
+                logger.info("Admin lesson plan generated: %d sections", len(admin_plan.sections))
+            else:
+                logger.warning("Admin plan generation failed: %s", results[1])
+        except Exception as e:
+            logger.warning("Parallel generation failed: %s", e)
+
         # ── Export all three files ────────────────────────────────────
         output_dir = Path("clawed_output").resolve()
         output_dir.mkdir(parents=True, exist_ok=True)
@@ -224,61 +278,39 @@ class GenerateLessonBundleTool:
         side_effects: list[str] = []
         errors: list[str] = []
 
-        # 1. Lesson plan DOCX
+        # 1. Admin lesson plan DOCX (or fallback to basic lesson plan)
         try:
             from clawed.export_docx import export_lesson_docx
 
-            docx_path = export_lesson_docx(lesson, persona, output_dir)
+            docx_path = export_lesson_docx(
+                lesson, persona, output_dir, admin_plan=admin_plan,
+            )
             generated_files.append(docx_path)
-            side_effects.append(f"Lesson plan DOCX: {docx_path.name}")
+            label = "Admin lesson plan" if admin_plan else "Lesson plan"
+            side_effects.append(f"{label} DOCX: {docx_path.name}")
         except Exception as e:
             logger.error("Lesson DOCX export failed: %s", e)
             errors.append(f"Lesson plan DOCX failed: {e}")
 
-        # 2. Generate student handout via LLM (first-class output, not regex extraction)
+        # 2. Student packet DOCX (structured) or fallback to old handout
         try:
-            import json_repair
+            from clawed.export_handout import export_student_packet_docx
 
-            from clawed.llm import LLMClient
-
-            llm_client = LLMClient(config)
-            handout_raw = await llm_client.generate_student_handout(
-                lesson_json_str,
-                persona_context=persona.to_prompt_context(),
-                subject=subject,
-                grade=grade,
-            )
-            # Parse handout JSON
-            handout_cleaned = handout_raw.strip()
-            if handout_cleaned.startswith("```"):
-                lines = handout_cleaned.split("\n")
-                lines = lines[1:]
-                if lines and lines[-1].strip() == "```":
-                    lines = lines[:-1]
-                handout_cleaned = "\n".join(lines)
-            try:
-                handout_data = json.loads(handout_cleaned)
-            except json.JSONDecodeError:
-                handout_data = json_repair.loads(handout_cleaned)
-
-            from clawed.export_handout import export_handout_docx
-
-            handout_path = export_handout_docx(handout_data, subject=subject)
-            if handout_path:
-                generated_files.append(Path(handout_path))
-                side_effects.append(f"Student handout DOCX: {Path(handout_path).name}")
-        except Exception as handout_err:
-            logger.warning("LLM handout generation failed, falling back: %s", handout_err)
-            # Fallback to regex-based handout
-            try:
+            if student_packet:
+                packet_path = export_student_packet_docx(
+                    student_packet, subject=subject, output_dir=output_dir,
+                )
+            else:
+                # Fallback: build minimal packet from lesson data
                 from clawed.export_docx import export_student_handout
+                packet_path = export_student_handout(lesson, persona, output_dir)
 
-                handout_path = export_student_handout(lesson, persona, output_dir)
-                if handout_path:
-                    generated_files.append(Path(handout_path))
-                    side_effects.append(f"Student handout DOCX: {Path(handout_path).name}")
-            except Exception:
-                pass
+            if packet_path:
+                generated_files.append(Path(packet_path))
+                side_effects.append(f"Student packet DOCX: {Path(packet_path).name}")
+        except Exception as e:
+            logger.warning("Student packet export failed: %s", e)
+            errors.append(f"Student packet failed: {e}")
 
         # 3. Slideshow PPTX
         try:

clawed-2.3.0/clawed/agent_core/tools/search_my_materials.py

@@ -0,0 +1,149 @@
+"""Tool: search_my_materials — search the teacher's uploaded curriculum files.
+
+This is the key tool that makes Claw-ED curriculum-aware. The agent calls
+this before generating to find relevant prior work in the teacher's own
+uploaded materials. Now includes asset-level awareness (slideshows, handouts,
+YouTube links) alongside text chunk search.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from clawed.agent_core.context import AgentContext, ToolResult
+
+
+class SearchMyMaterialsTool:
+    """Search the teacher's curriculum knowledge base for relevant content."""
+
+    def schema(self) -> dict[str, Any]:
+        return {
+            "type": "function",
+            "function": {
+                "name": "search_my_materials",
+                "description": (
+                    "Search the teacher's uploaded curriculum files for relevant "
+                    "content. Use this BEFORE generating lessons, units, or materials "
+                    "to ground your output in the teacher's own prior work. Returns "
+                    "matching files (slideshows, handouts, assessments), YouTube links, "
+                    "and text excerpts with source file attribution."
+                ),
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "query": {
+                            "type": "string",
+                            "description": (
+                                "What to search for — a topic, concept, or question. "
+                                "Example: 'Civil War causes', 'photosynthesis lab', "
+                                "'fractions worksheet'"
+                            ),
+                        },
+                        "top_k": {
+                            "type": "integer",
+                            "description": "Maximum results to return (default 5)",
+                            "default": 5,
+                        },
+                    },
+                    "required": ["query"],
+                },
+            },
+        }
+
+    async def execute(
+        self, params: dict[str, Any], context: AgentContext
+    ) -> ToolResult:
+        query = params["query"]
+        top_k = params.get("top_k", 5)
+        teacher_id = context.teacher_id
+
+        lines: list[str] = []
+
+        # ── Asset-level search (files, YouTube links) ──────────────
+        try:
+            from clawed.asset_registry import AssetRegistry
+            registry = AssetRegistry()
+            assets = registry.search_assets(teacher_id, query, top_k=top_k)
+            yt_links = registry.get_youtube_links(teacher_id, query, top_k=3)
+
+            if assets:
+                lines.append("EXISTING MATERIALS:\n")
+                for i, a in enumerate(assets, 1):
+                    type_label = a["material_type"].replace("_", " ").title()
+                    extras: list[str] = []
+                    if a.get("slide_count"):
+                        extras.append(f"{a['slide_count']} slides")
+                    if a.get("image_count"):
+                        extras.append(f"{a['image_count']} images")
+                    yt_raw = a.get("youtube_urls", [])
+                    yt_list = json.loads(yt_raw) if isinstance(yt_raw, str) else yt_raw
+                    yt_count = len(yt_list)
+                    if yt_count:
+                        extras.append(f"{yt_count} YouTube links")
+                    extra_str = f" ({', '.join(extras)})" if extras else ""
+                    lines.append(
+                        f"  {i}. [{type_label}] \"{a['title']}\"{extra_str}\n"
+                        f"     File: {a['filename']}\n"
+                    )
+
+            if yt_links:
+                lines.append("YOUTUBE LINKS IN YOUR FILES:\n")
+                for link in yt_links:
+                    lines.append(f"  - {link['url']} (from \"{link['from_file']}\")\n")
+
+        except Exception:
+            pass
+
+        # ── Chunk-level search (text excerpts) ─────────────────────
+        try:
+            from clawed.agent_core.memory.curriculum_kb import CurriculumKB
+
+            kb = CurriculumKB()
+            results = kb.search(teacher_id, query, top_k=top_k)
+
+            if not results and not lines:
+                stats = kb.stats(teacher_id)
+                if stats["doc_count"] == 0:
+                    return ToolResult(
+                        text="No curriculum files uploaded yet. Ask the teacher "
+                             "to share their lesson plans, handouts, or other "
+                             "teaching materials so you can reference them."
+                    )
+                return ToolResult(
+                    text=f"No matches found for '{query}' in "
+                         f"{stats['doc_count']} uploaded documents."
+                )
+
+            if results:
+                lines.append("RELEVANT EXCERPTS:\n")
+                for i, r in enumerate(results, 1):
+                    source = r["doc_title"]
+                    if r.get("source_path"):
+                        fname = Path(r["source_path"]).name
+                        source = f"{r['doc_title']} ({fname})"
+                    sim_pct = int(r["similarity"] * 100)
+                    text_preview = r["chunk_text"][:300]
+                    if len(r["chunk_text"]) > 300:
+                        text_preview += "..."
+                    lines.append(
+                        f"  {i}. From '{source}' ({sim_pct}% match):\n"
+                        f"     {text_preview}\n"
+                    )
+
+        except Exception as e:
+            if not lines:
+                return ToolResult(text=f"Failed to search curriculum files: {e}")
+
+        if lines:
+            header = f"Found materials related to \"{query}\":\n\n"
+            lines.append(
+                "\nWould you like me to use these existing materials, "
+                "enhance them, or create something new?"
+            )
+            return ToolResult(
+                text=header + "\n".join(lines),
+                data={"query": query},
+            )
+
+        return ToolResult(text=f"No materials found for '{query}'.")

{clawed-2.1.0 → clawed-2.3.0}/clawed/commands/generate.py

@@ -155,20 +155,26 @@ def ingest(
     except Exception:
         pass
 
-    # Register assets (file-level metadata, images, YouTube links)
+    # Register assets with rich extraction (images, YouTube links, metadata)
     asset_msg = ""
     try:
         from clawed.asset_registry import AssetRegistry
+        from clawed.ingestor import extract_rich
         registry = AssetRegistry()
         asset_count = 0
         for doc in documents:
             doc_type_val = doc.doc_type.value if hasattr(doc.doc_type, "value") else str(doc.doc_type)
+            # Try rich extraction for images/URLs from original file
+            extraction = None
+            if doc.source_path:
+                extraction = extract_rich(Path(doc.source_path))
             asset_id = registry.register_asset(
                 teacher_id="default",
                 source_path=doc.source_path or "",
                 title=doc.title,
                 doc_type=doc_type_val,
                 text=doc.content,
+                extraction=extraction,
             )
             if asset_id:
                 asset_count += 1