clawed 2.0.4__tar.gz → 2.1.1__tar.gz

{clawed-2.0.4 → clawed-2.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clawed
-Version: 2.0.4
+Version: 2.1.1
 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

{clawed-2.0.4 → clawed-2.1.1}/clawed/__init__.py

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

{clawed-2.0.4 → clawed-2.1.1}/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)

clawed-2.1.1/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.1/clawed/asset_registry.py

@@ -0,0 +1,409 @@
+"""Asset registry — file-level awareness of teacher's materials.
+
+Sits alongside the curriculum KB (same SQLite database). While the KB stores
+text chunks for semantic search, the asset registry stores one row per *file*
+with rich metadata: material type, embedded images, YouTube links, slide counts.
+
+This powers the "I found your Reconstruction PPT from 2020" experience.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+import re
+import sqlite3
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_DB = Path.home() / ".eduagent" / "memory" / "curriculum_kb.db"
+
+# ── YouTube URL normalization ────────────────────────────────────────
+
+_YT_PATTERNS = [
+    re.compile(r'(?:https?://)?(?:www\.)?youtube\.com/watch\?v=([a-zA-Z0-9_-]{11})'),
+    re.compile(r'(?:https?://)?youtu\.be/([a-zA-Z0-9_-]{11})'),
+    re.compile(r'(?:https?://)?(?:www\.)?youtube\.com/embed/([a-zA-Z0-9_-]{11})'),
+    re.compile(r'(?:https?://)?m\.youtube\.com/watch\?v=([a-zA-Z0-9_-]{11})'),
+]
+
+_URL_PATTERN = re.compile(r'https?://[^\s<>"\')\]]+')
+
+
+def extract_youtube_ids(text: str) -> list[str]:
+    """Extract unique YouTube video IDs from text."""
+    ids: list[str] = []
+    for pat in _YT_PATTERNS:
+        for m in pat.finditer(text):
+            vid = m.group(1)
+            if vid not in ids:
+                ids.append(vid)
+    return ids
+
+
+def extract_urls(text: str) -> list[str]:
+    """Extract all URLs from text."""
+    return _URL_PATTERN.findall(text)
+
+
+def classify_url(url: str) -> str:
+    """Classify a URL type."""
+    lower = url.lower()
+    if 'youtube.com' in lower or 'youtu.be' in lower:
+        return 'youtube'
+    if 'docs.google.com' in lower or 'drive.google.com' in lower:
+        return 'google_doc'
+    return 'website'
+
+
+# ── Material type classification ─────────────────────────────────────
+
+_ASSESSMENT_KEYWORDS = {'test', 'quiz', 'exam', 'assessment', 'midterm', 'final', 'regents'}
+_HANDOUT_KEYWORDS = {'handout', 'worksheet', 'graphic organizer', 'organizer', 'guided notes'}
+_UNIT_PLAN_KEYWORDS = {'unit plan', 'essential questions', 'enduring understandings', 'pacing'}
+_LESSON_PLAN_KEYWORDS = {'lesson plan', 'objective', 'do now', 'exit ticket', 'swbat'}
+
+
+def classify_material_type(
+    doc_type: str, text: str, filename: str, slide_count: int | None = None,
+) -> str:
+    """Classify a document into a material type using heuristics."""
+    lower_fn = filename.lower()
+    lower_text = text[:2000].lower()
+
+    if doc_type == 'pptx':
+        if slide_count and slide_count >= 8:
+            return 'slideshow'
+        if slide_count and slide_count <= 3:
+            return 'fragment'
+        return 'slideshow'
+
+    combined = lower_fn + " " + lower_text
+
+    if any(kw in combined for kw in _ASSESSMENT_KEYWORDS):
+        return 'assessment'
+    if any(kw in combined for kw in _HANDOUT_KEYWORDS):
+        return 'handout'
+    if any(kw in combined for kw in _UNIT_PLAN_KEYWORDS):
+        return 'unit_plan'
+    if any(kw in combined for kw in _LESSON_PLAN_KEYWORDS):
+        return 'lesson_plan'
+    if doc_type == 'docx':
+        return 'notes'
+    return 'unknown'
+
+
+# ── Extracted metadata dataclasses ───────────────────────────────────
+
+@dataclass
+class ExtractedImage:
+    """An image extracted from a teaching document."""
+    image_bytes: bytes
+    format: str  # 'png', 'jpeg', 'gif'
+    width: int | None = None
+    height: int | None = None
+    alt_text: str = ''
+    context_text: str = ''
+    slide_number: int | None = None
+
+
+@dataclass
+class ExtractedURL:
+    """A URL found in a teaching document."""
+    url: str
+    link_type: str  # 'youtube', 'website', 'google_doc'
+    context_text: str = ''
+    title_hint: str = ''
+
+
+@dataclass
+class ExtractionResult:
+    """Rich extraction result from a document."""
+    text: str
+    page_count: int | None = None
+    slide_count: int | None = None
+    images: list[ExtractedImage] = field(default_factory=list)
+    urls: list[ExtractedURL] = field(default_factory=list)
+    word_count: int = 0
+
+
+# ── Asset Registry ───────────────────────────────────────────────────
+
+class AssetRegistry:
+    """File-level asset registry for teacher's materials.
+
+    Tracks complete files (slideshows, handouts, assessments) with metadata
+    about embedded images, YouTube links, material type, and completeness.
+    """
+
+    def __init__(self, db_path: Path | None = None):
+        self._db_path = db_path or _DEFAULT_DB
+        self._db_path.parent.mkdir(parents=True, exist_ok=True)
+        self._init_db()
+
+    def _init_db(self) -> None:
+        with sqlite3.connect(self._db_path) as conn:
+            conn.executescript("""
+                CREATE TABLE IF NOT EXISTS assets (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    teacher_id TEXT NOT NULL,
+                    source_path TEXT NOT NULL,
+                    filename TEXT NOT NULL,
+                    doc_type TEXT NOT NULL,
+                    material_type TEXT NOT NULL,
+                    title TEXT NOT NULL,
+                    topic_tags TEXT DEFAULT '[]',
+                    grade_hint TEXT DEFAULT '',
+                    slide_count INTEGER,
+                    page_count INTEGER,
+                    word_count INTEGER DEFAULT 0,
+                    has_images INTEGER DEFAULT 0,
+                    image_count INTEGER DEFAULT 0,
+                    youtube_urls TEXT DEFAULT '[]',
+                    external_urls TEXT DEFAULT '[]',
+                    completeness TEXT DEFAULT 'unknown',
+                    file_size_bytes INTEGER,
+                    content_hash TEXT NOT NULL,
+                    indexed_at TEXT NOT NULL,
+                    UNIQUE(teacher_id, content_hash)
+                );
+                CREATE INDEX IF NOT EXISTS idx_assets_teacher
+                    ON assets(teacher_id);
+                CREATE INDEX IF NOT EXISTS idx_assets_material_type
+                    ON assets(teacher_id, material_type);
+
+                CREATE TABLE IF NOT EXISTS asset_images (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    asset_id INTEGER NOT NULL REFERENCES assets(id),
+                    image_index INTEGER NOT NULL,
+                    image_path TEXT NOT NULL,
+                    image_format TEXT DEFAULT '',
+                    width_px INTEGER,
+                    height_px INTEGER,
+                    alt_text TEXT DEFAULT '',
+                    context_text TEXT DEFAULT '',
+                    slide_number INTEGER,
+                    UNIQUE(asset_id, image_index)
+                );
+
+                CREATE TABLE IF NOT EXISTS asset_links (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    asset_id INTEGER NOT NULL REFERENCES assets(id),
+                    url TEXT NOT NULL,
+                    link_type TEXT NOT NULL,
+                    context_text TEXT DEFAULT '',
+                    title_hint TEXT DEFAULT '',
+                    UNIQUE(asset_id, url)
+                );
+            """)
+
+    def register_asset(
+        self,
+        teacher_id: str,
+        source_path: str,
+        title: str,
+        doc_type: str,
+        text: str,
+        extraction: ExtractionResult | None = None,
+    ) -> int | None:
+        """Register a file as an asset. Returns asset ID or None if duplicate."""
+        content_hash = hashlib.sha256(text.encode("utf-8", errors="replace")).hexdigest()[:32]
+        filename = Path(source_path).name
+
+        material_type = classify_material_type(
+            doc_type, text, filename,
+            slide_count=extraction.slide_count if extraction else None,
+        )
+
+        word_count = len(text.split()) if text else 0
+        slide_count = extraction.slide_count if extraction else None
+        page_count = extraction.page_count if extraction else None
+
+        # Extract URLs from text
+        yt_ids = extract_youtube_ids(text)
+        youtube_urls = [f"https://youtube.com/watch?v={vid}" for vid in yt_ids]
+        all_urls = extract_urls(text)
+        external_urls = [u for u in all_urls if 'youtube' not in u.lower() and 'youtu.be' not in u.lower()]
+
+        # Add URLs from extraction result
+        if extraction:
+            for eu in extraction.urls:
+                if eu.link_type == 'youtube' and eu.url not in youtube_urls:
+                    youtube_urls.append(eu.url)
+                elif eu.url not in external_urls:
+                    external_urls.append(eu.url)
+
+        image_count = len(extraction.images) if extraction else 0
+        has_images = 1 if image_count > 0 else 0
+
+        try:
+            file_size = Path(source_path).stat().st_size if Path(source_path).exists() else 0
+        except Exception:
+            file_size = 0
+
+        completeness = 'complete' if material_type in ('slideshow', 'assessment', 'handout') else 'unknown'
+
+        try:
+            with sqlite3.connect(self._db_path) as conn:
+                cursor = conn.execute(
+                    "INSERT OR IGNORE INTO assets "
+                    "(teacher_id, source_path, filename, doc_type, material_type, title, "
+                    "word_count, slide_count, page_count, has_images, image_count, "
+                    "youtube_urls, external_urls, completeness, file_size_bytes, "
+                    "content_hash, indexed_at) "
+                    "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+                    (
+                        teacher_id, source_path, filename, doc_type, material_type, title,
+                        word_count, slide_count, page_count, has_images, image_count,
+                        json.dumps(youtube_urls), json.dumps(external_urls),
+                        completeness, file_size, content_hash,
+                        datetime.now().isoformat(),
+                    ),
+                )
+                if cursor.rowcount == 0:
+                    return None  # duplicate
+                asset_id = cursor.lastrowid
+
+                # Store image references
+                if extraction and extraction.images:
+                    cache_dir = self._db_path.parent.parent / "cache" / "extracted" / content_hash
+                    cache_dir.mkdir(parents=True, exist_ok=True)
+                    for idx, img in enumerate(extraction.images):
+                        ext = img.format.lower().replace('jpeg', 'jpg')
+                        img_path = cache_dir / f"{idx}.{ext}"
+                        try:
+                            img_path.write_bytes(img.image_bytes)
+                            conn.execute(
+                                "INSERT OR IGNORE INTO asset_images "
+                                "(asset_id, image_index, image_path, image_format, "
+                                "width_px, height_px, alt_text, context_text, slide_number) "
+                                "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+                                (
+                                    asset_id, idx, str(img_path), img.format,
+                                    img.width, img.height, img.alt_text,
+                                    img.context_text, img.slide_number,
+                                ),
+                            )
+                        except Exception as e:
+                            logger.debug("Failed to save image %d: %s", idx, e)
+
+                # Store link references
+                for yt_url in youtube_urls:
+                    conn.execute(
+                        "INSERT OR IGNORE INTO asset_links "
+                        "(asset_id, url, link_type, context_text) VALUES (?, ?, ?, ?)",
+                        (asset_id, yt_url, 'youtube', ''),
+                    )
+                for ext_url in external_urls[:20]:  # cap at 20 external URLs
+                    conn.execute(
+                        "INSERT OR IGNORE INTO asset_links "
+                        "(asset_id, url, link_type, context_text) VALUES (?, ?, ?, ?)",
+                        (asset_id, ext_url, classify_url(ext_url), ''),
+                    )
+
+                return asset_id
+        except Exception as e:
+            logger.debug("Asset registration failed: %s", e)
+            return None
+
+    def search_assets(
+        self, teacher_id: str, query: str, top_k: int = 10,
+    ) -> list[dict[str, Any]]:
+        """Search assets by keyword matching on title, filename, and material type."""
+        keywords = [w.lower() for w in query.split() if len(w) > 2]
+        if not keywords:
+            return []
+
+        with sqlite3.connect(self._db_path) as conn:
+            conn.row_factory = sqlite3.Row
+            rows = conn.execute(
+                "SELECT * FROM assets WHERE teacher_id = ?", (teacher_id,),
+            ).fetchall()
+
+        scored: list[tuple[float, dict]] = []
+        for row in rows:
+            title_lower = row["title"].lower()
+            fn_lower = row["filename"].lower()
+            combined = title_lower + " " + fn_lower
+            score = sum(1 for kw in keywords if kw in combined)
+            if score > 0:
+                asset = dict(row)
+                asset["youtube_urls"] = json.loads(asset["youtube_urls"])
+                asset["external_urls"] = json.loads(asset["external_urls"])
+                scored.append((score, asset))
+
+        scored.sort(key=lambda x: (-x[0], x[1].get("material_type", "")))
+        return [item[1] for item in scored[:top_k]]
+
+    def get_youtube_links(self, teacher_id: str, query: str, top_k: int = 5) -> list[dict]:
+        """Search for YouTube links related to a topic."""
+        assets = self.search_assets(teacher_id, query, top_k=50)
+        links: list[dict] = []
+        seen: set[str] = set()
+        for asset in assets:
+            for yt_url in asset.get("youtube_urls", []):
+                if yt_url not in seen:
+                    seen.add(yt_url)
+                    links.append({
+                        "url": yt_url,
+                        "from_file": asset["title"],
+                        "material_type": asset["material_type"],
+                    })
+                    if len(links) >= top_k:
+                        return links
+        return links
+
+    def format_asset_summary(self, assets: list[dict], youtube_links: list[dict] | None = None) -> str:
+        """Format a human-readable summary of found assets."""
+        if not assets and not youtube_links:
+            return ""
+
+        lines: list[str] = []
+        if assets:
+            lines.append("Teacher's Existing Materials on This Topic:")
+            for a in assets:
+                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_count = len(a.get("youtube_urls", []))
+                if yt_count:
+                    extras.append(f"{yt_count} YouTube links")
+                extra_str = f" ({', '.join(extras)})" if extras else ""
+                lines.append(f"  - [{type_label}] \"{a['title']}\"{extra_str}")
+                lines.append(f"    File: {a['filename']}")
+
+        if youtube_links:
+            lines.append("\nYouTube Links Found in Your Files:")
+            for link in youtube_links:
+                lines.append(f"  - {link['url']} (from \"{link['from_file']}\")")
+
+        lines.append(
+            "\nReference and build on these existing materials. "
+            "If the teacher has taught this topic before, extend their work."
+        )
+        return "\n".join(lines)
+
+    def stats(self, teacher_id: str) -> dict[str, int]:
+        """Return asset counts."""
+        with sqlite3.connect(self._db_path) as conn:
+            total = conn.execute(
+                "SELECT COUNT(*) FROM assets WHERE teacher_id = ?", (teacher_id,),
+            ).fetchone()[0]
+            images = conn.execute(
+                "SELECT COUNT(*) FROM asset_images ai "
+                "JOIN assets a ON ai.asset_id = a.id WHERE a.teacher_id = ?",
+                (teacher_id,),
+            ).fetchone()[0]
+            links = conn.execute(
+                "SELECT COUNT(*) FROM asset_links al "
+                "JOIN assets a ON al.asset_id = a.id WHERE a.teacher_id = ?",
+                (teacher_id,),
+            ).fetchone()[0]
+        return {"asset_count": total, "image_count": images, "link_count": links}