@topy-ai/maggie 0.7.0 → 0.7.1

package/bundled-tools/runtime/maggie_sitemap.py

@@ -55,6 +55,12 @@ def filter_routes(routes: list[dict[str, str]], origin: str, content_types: set[
             reason = "content type not enabled"
         elif not absolute_url(url, origin):
             reason = "URL must be an absolute HTTP(S) URL on the approved origin"
+        elif route.get("indexable") is False:
+            reason = "route is explicitly non-indexable"
+        elif route.get("canonicalUrl") and route.get("canonicalUrl") != url:
+            reason = "route canonical URL does not self-canonicalize"
+        elif route.get("searchable") is False:
+            reason = "route is explicitly not searchable"
         elif EXCLUDED_PATHS.search(parsed.path) or any(key in parse_qs(parsed.query) for key in ("q", "search", "filter", "page")):
             reason = "search, filter, or non-canonical route"
         elif route.get("type", "").lower() in {"rss", "atom", "feed"}:
@@ -86,12 +92,12 @@ def build_plan(routes: list[dict[str, str]], origin: str, content_types: set[str
     for content_type in sorted(content_types):
         chunks = []
         entries = groups.get(content_type, []) or []
-        for index in range(0, max(len(entries), 1), chunk_target):
+        for index in range(0, len(entries), chunk_target):
             chunk_entries = entries[index:index + chunk_target]
             filename = f"sitemap-{content_type}-{index // chunk_target + 1}.xml"
             xml = xml_file(chunk_entries)
             url = origin.rstrip("/") + "/" + filename
-            chunks.append({"filename": filename, "url": url, "entries": len(chunk_entries), "bytes": len(xml.encode()), "sha256": hashlib.sha256(xml.encode()).hexdigest(), "xml": xml})
+            chunks.append({"filename": filename, "url": url, "entries": len(chunk_entries), "routes": chunk_entries, "bytes": len(xml.encode()), "sha256": hashlib.sha256(xml.encode()).hexdigest(), "xml": xml})
             sitemap_urls.append(url)
         group_plans.append({"contentType": content_type, "chunks": chunks})
     index_xml = '<?xml version="1.0" encoding="UTF-8"?>\n<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">' + "".join(f"<sitemap><loc>{escape(url)}</loc></sitemap>" for url in sitemap_urls) + "</sitemapindex>\n"
@@ -103,7 +109,7 @@ def build_plan(routes: list[dict[str, str]], origin: str, content_types: set[str
     return plan
 
 
-def validate_plan_data(plan: dict) -> dict:
+def validate_plan_data(plan: dict, strict_semantic: bool = False) -> dict:
     errors = []
     warnings = []
     origin = plan.get("origin", "")
@@ -117,6 +123,21 @@ def validate_plan_data(plan: dict) -> dict:
                 errors.append(f"chunk exceeds URL limit: {chunk.get('filename')}")
             if chunk.get("bytes", 0) > HARD_BYTES_LIMIT:
                 errors.append(f"chunk exceeds byte limit: {chunk.get('filename')}")
+            for route in chunk.get("routes", []):
+                if route.get("indexable") is False or route.get("searchable") is False:
+                    errors.append(f"non-indexable/searchable route was emitted: {route.get('url')}")
+                if route.get("canonicalUrl") and route.get("canonicalUrl") != route.get("url"):
+                    errors.append(f"non-self-canonical route was emitted: {route.get('url')}")
+                if "contentWords" in route and int(route.get("contentWords") or 0) < 1:
+                    errors.append(f"route has no searchable content evidence: {route.get('url')}")
+                if "title" in route and not str(route.get("title") or "").strip():
+                    errors.append(f"route has no title evidence: {route.get('url')}")
+                if route.get("lastmod") and route.get("lastmodSource") in {"updated_at", "sync", "pull", "deploy"}:
+                    errors.append(f"lastmod is derived from an operational timestamp: {route.get('url')}")
+                if route.get("lastmod") and route.get("lastmodSource") not in {None, "content-change", "source-revision"}:
+                    errors.append(f"lastmod provenance is not a content change: {route.get('url')}")
+                if route.get("lastmod") and strict_semantic and route.get("lastmodSource") not in {"content-change", "source-revision"}:
+                    errors.append(f"lastmod evidence is required for strict semantic validation: {route.get('url')}")
             try:
                 root = ElementTree.fromstring(chunk.get("xml", ""))
                 locs = [element.text or "" for element in root.iter() if element.tag.endswith("loc")]
@@ -140,5 +161,30 @@ def validate_plan_data(plan: dict) -> dict:
     except ElementTree.ParseError:
         errors.append("sitemap index is not valid XML")
     if not expected_urls:
-        warnings.append("no sitemap chunks generated")
+        warnings.append("no sitemap chunks generated; empty content types are not advertised")
+    if strict_semantic:
+        for group in plan.get("groups", []):
+            for chunk in group.get("chunks", []):
+                for route in chunk.get("routes", []):
+                    if not str(route.get("title") or "").strip(): warnings.append(f"semantic title evidence missing: {route.get('url')}")
+                    if "contentWords" not in route: warnings.append(f"semantic content evidence missing: {route.get('url')}")
+        if warnings:
+            errors.extend(warnings)
     return {"status": "pass" if not errors else "fail", "errors": errors, "warnings": warnings}
+
+
+def agent_files(routes: list[dict[str, str]], origin: str, locale: str = "en") -> dict[str, str]:
+    """Generate compact, locale-aware agent discovery documents."""
+    visible = [route for route in routes if route.get("indexable") is not False and route.get("searchable") is not False and absolute_url(route.get("url", ""), origin)]
+    visible.sort(key=lambda route: route.get("url", ""))
+    lines = [f"# {origin} ({locale})", "", "This file lists indexable public routes for agent discovery.", "", "## Routes"]
+    for route in visible:
+        label = route.get("title") or route.get("url", "").rstrip("/").rsplit("/", 1)[-1] or "home"
+        lines.append(f"- [{label}]({route['url']})")
+    sitemap = [f"# Sitemap ({locale})", "", f"- XML sitemap: {origin.rstrip('/')}/sitemap.xml", "", "## Public routes"]
+    sitemap.extend(f"- {route['url']}" for route in visible)
+    insights = [f"# Content insights ({locale})", "", f"- Indexable routes: {len(visible)}", f"- Content types: {', '.join(sorted({str(route.get('type', 'unknown')) for route in visible})) or 'none'}", "", "## Freshness"]
+    for route in visible:
+        if route.get("lastmod"):
+            insights.append(f"- {route['url']}: last content change {route['lastmod']}")
+    return {"llms.txt": "\n".join(lines) + "\n", "sitemap.md": "\n".join(sitemap) + "\n", "insights.md": "\n".join(insights) + "\n"}

package/bundled-tools/runtime/route_imports.py

@@ -0,0 +1,51 @@
+"""Resolve route components from source imports, never from sibling basenames."""
+
+from __future__ import annotations
+
+import hashlib
+import re
+from pathlib import Path
+
+
+IMPORT_RE = re.compile(r"(?:import\s+(?:[^;\n]*?\s+from\s+)?|export\s+[^;\n]*?\s+from\s+)[\"']([^\"']+)[\"']")
+EXTENSIONS = ("", ".astro", ".tsx", ".jsx", ".ts", ".js", ".vue", ".svelte", ".html")
+
+
+def resolve_import(route: Path, specifier: str) -> Path | None:
+    if not specifier.startswith("."):
+        return None
+    base = (route.parent / specifier).resolve()
+    candidates = [base]
+    candidates.extend(Path(str(base) + extension) for extension in EXTENSIONS[1:])
+    candidates.extend(base / f"index{extension}" for extension in EXTENSIONS)
+    for candidate in candidates:
+        if candidate.is_file():
+            return candidate
+    return None
+
+
+def imported_components(route: Path) -> list[dict[str, str | None]]:
+    """Return only source imports that resolve inside the project.
+
+    Bare package imports are intentionally recorded without a local path; they
+    are dependencies, not route-local components. The route source remains
+    the authority, so a same-named sibling file is never selected implicitly.
+    """
+    try:
+        source = route.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return []
+    result = []
+    seen = set()
+    for specifier in IMPORT_RE.findall(source):
+        resolved = resolve_import(route, specifier)
+        key = (specifier, str(resolved) if resolved else None)
+        if key in seen:
+            continue
+        seen.add(key)
+        result.append({
+            "specifier": specifier,
+            "path": str(resolved) if resolved else None,
+            "fingerprint": hashlib.sha256(resolved.read_bytes()).hexdigest() if resolved else None,
+        })
+    return result

package/bundled-tools/runtime/seed_evidence.py

@@ -0,0 +1,25 @@
+"""Validation for explicit, sanitized development fixture evidence."""
+
+from __future__ import annotations
+
+import re
+
+
+SECRET = re.compile(r"(?:secret|token|password|api[_-]?key|database_url)", re.I)
+
+
+def validate_manifest(value: object) -> dict:
+    errors = []
+    if not isinstance(value, dict):
+        return {"schemaVersion": "maggie-seed-manifest.v1", "passed": False, "errors": ["manifest must be an object"]}
+    if value.get("schemaVersion") != "maggie-seed-manifest.v1": errors.append("unsupported schemaVersion")
+    if value.get("optIn") is not True: errors.append("optIn must be true")
+    if value.get("sanitized") is not True: errors.append("sanitized must be true")
+    fixtures = value.get("fixtures")
+    if not isinstance(fixtures, list) or not fixtures: errors.append("fixtures must be a non-empty list")
+    for item in fixtures if isinstance(fixtures, list) else []:
+        if not isinstance(item, dict) or not item.get("name") or not item.get("rows"):
+            errors.append("each fixture requires name and non-empty rows")
+        if SECRET.search(str(item)):
+            errors.append("fixture contains a secret-like field")
+    return {"schemaVersion": "maggie-seed-manifest.v1", "passed": not errors, "errors": errors, "fixtureCount": len(fixtures) if isinstance(fixtures, list) else 0}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@topy-ai/maggie",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "Install and manage Maggie Skills for AI coding agents",
   "license": "MIT",
   "type": "module",

package/references/maggiedash-dashboard-ui.md

@@ -0,0 +1,28 @@
+# MaggieDash dashboard UI contract
+
+MaggieDash workspaces use the lightweight contract in
+`templates/maggiedash/dashboard-ui-contract.json`. It is provider-neutral and
+describes the dashboard chrome, not a framework-specific component library.
+
+The reference is the users workspace: one `WorkspaceBar`, one sidebar/content
+navigation relationship, and one `ContentTabs` row. A route must not render a
+second horizontal navigation, duplicate its sidebar, or hide duplicate markup
+with CSS. `WorkspaceCard` owns card framing; page routes own content.
+
+`ContentTabs` accepts only the props it renders (`tabs`, `active`, `actions`,
+and `children`). It does not accept a page `title` or `description`. If a page
+needs a heading or description, render a dedicated page header or use
+`WorkspaceBar` explicitly. This keeps component APIs honest and prevents
+dead-copy drift.
+
+Validate a host implementation with:
+
+```bash
+maggie dash ui validate --contract templates/maggiedash/dashboard-ui-contract.json \
+  --source src/components/WorkspaceBar.tsx \
+  --source src/components/WorkspaceCard.tsx \
+  --source src/components/ContentTabs.tsx
+```
+
+The check is static evidence. It does not replace an authenticated browser
+review of the rendered dashboard at desktop and mobile sizes.