@topy-ai/maggie 0.7.52 → 0.7.54

package/bundled-tools/clis/maggie_dash.py

@@ -252,7 +252,7 @@ def merge_astro_middleware(path: Path) -> dict[str, object]:
     return {"status": "updated", "reason": "inserted idempotent Maggie rewrite block"}
 
 
-def manifest_host_file_pairs(source: Path, manifest: dict[str, object], root: Path, framework: str | None) -> list[tuple[Path, Path, Path]]:
+def manifest_host_file_pairs(source: Path, manifest: dict[str, object], root: Path, framework: str | None, required: bool = True) -> list[tuple[Path, Path, Path]]:
     """Return non-destructive host files for a declared framework adapter."""
     if not framework:
         return []
@@ -260,6 +260,8 @@ def manifest_host_file_pairs(source: Path, manifest: dict[str, object], root: Pa
     if not isinstance(bootstrap, dict):
         return []
     spec = bootstrap.get(framework)
+    if not isinstance(spec, dict) and not required:
+        return []
     if not isinstance(spec, dict):
         raise RuntimeError(
             f"MaggieDash distribution at {source} does not provide a {framework} host bootstrap; "
@@ -288,6 +290,128 @@ def manifest_host_file_pairs(source: Path, manifest: dict[str, object], root: Pa
     return pairs
 
 
+CORE_MODULE = "core"
+
+
+def module_names(manifest: dict[str, object]) -> list[str]:
+    modules = manifest.get("modules")
+    return sorted(modules) if isinstance(modules, dict) else []
+
+
+def effective_manifest(manifest: dict[str, object], modules: list[str]) -> dict[str, object]:
+    """Core entries plus the root files and workspaces of the chosen modules."""
+    result = dict(manifest)
+    specs = manifest.get("modules") if isinstance(manifest.get("modules"), dict) else {}
+    root_files = list(manifest.get("rootFiles", []))
+    workspaces = list(manifest.get("workspaces", []))
+    for name in modules:
+        spec = specs.get(name) or {}
+        root_files.extend(spec.get("rootFiles", []))
+        workspaces.extend(spec.get("workspaces", []))
+    result["rootFiles"] = root_files
+    result["workspaces"] = workspaces
+    return result
+
+
+def resolve_modules(manifest: dict[str, object], requested: list[str], previous: list[str]) -> list[str]:
+    available = module_names(manifest)
+    if requested and not available:
+        # A release without the module split installs everything already.
+        return []
+    unknown = sorted(set(requested) - set(available))
+    if unknown:
+        raise RuntimeError(f"unknown MaggieDash module(s): {', '.join(unknown)}; this release offers: {', '.join(available) or 'none'}")
+    # Re-running install keeps refreshing modules that were added before.
+    return sorted((set(requested) | set(previous)) & set(available))
+
+
+def installed_state(root: Path) -> dict[str, object]:
+    try:
+        value = json.loads((root / ".maggie" / "dash-install.json").read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}
+    return value if isinstance(value, dict) else {}
+
+
+def package_dependencies(root: Path) -> set[str]:
+    try:
+        value = json.loads((root / "package.json").read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return set()
+    return set(value.get("dependencies") or {}) | set(value.get("devDependencies") or {})
+
+
+SERVICE_WORDS = re.compile(r"\b(book (?:now|an? (?:appointment|session|treatment|table))|appointments?|treatments?|reservations?|book online|opening hours)\b", re.I)
+LOCALE_DIR = re.compile(r"^(?:[a-z]{2}(?:-[a-z]{2,4})?)$")
+
+
+def analyse_host(root: Path, framework: str | None) -> dict[str, object]:
+    """What the host already has, read from files only (nothing is executed)."""
+    deps = package_dependencies(root)
+    auth = sorted(name for name in deps if name in {"firebase", "firebase-admin", "next-auth", "lucia", "better-auth", "@supabase/supabase-js", "@supabase/ssr", "auth-astro"} or name.startswith(("@clerk/", "@auth/")))
+    database = sorted(name for name in deps if name in {"pg", "postgres", "@neondatabase/serverless", "drizzle-orm", "prisma", "@prisma/client", "mysql2", "better-sqlite3", "@libsql/client", "kysely"})
+    for config in ("wrangler.json", "wrangler.jsonc", "wrangler.toml"):
+        path = root / config
+        if path.is_file() and "d1_databases" in path.read_text(encoding="utf-8", errors="replace"):
+            database.append("cloudflare-d1")
+    payments = sorted(name for name in deps if name in {"stripe", "@stripe/stripe-js", "@paypal/checkout-server-sdk", "@lemonsqueezy/lemonsqueezy.js"})
+    source = root / "src"
+    service_hits: list[str] = []
+    if source.is_dir():
+        for path in sorted(source.rglob("*")):
+            if len(service_hits) >= 5:
+                break
+            if path.is_file() and path.suffix in {".astro", ".md", ".mdx", ".tsx", ".jsx", ".ts", ".json", ".html", ".vue", ".svelte"} and "_maggie" not in path.parts and "maggie" not in path.parts:
+                try:
+                    if SERVICE_WORDS.search(path.read_text(encoding="utf-8", errors="replace")[:200_000]):
+                        service_hits.append(str(path.relative_to(root)))
+                except OSError:
+                    continue
+    blog = any((root / candidate).exists() for candidate in ("src/content/blog", "src/content/posts", "src/pages/blog", "src/pages/blog.astro", "src/pages/posts", "content/blog", "app/blog"))
+    locales: set[str] = set()
+    for pages in (root / "src" / "pages", root / "app"):
+        if pages.is_dir():
+            locales.update(child.name for child in pages.iterdir() if child.is_dir() and LOCALE_DIR.match(child.name) and child.name not in {"api", "og"})
+    astro_config = next((path for path in root.glob("astro.config.*")), None)
+    if astro_config:
+        match = re.search(r"locales\s*:\s*\[([^\]]+)\]", astro_config.read_text(encoding="utf-8", errors="replace"))
+        if match:
+            locales.update(re.findall(r"[\"']([A-Za-z-]+)[\"']", match.group(1)))
+    return {
+        "framework": framework,
+        "auth": auth,
+        "database": sorted(set(database)),
+        "payments": payments,
+        "sellsServices": bool(service_hits),
+        "serviceEvidence": service_hits,
+        "blog": blog,
+        "locales": sorted(locales),
+    }
+
+
+def recommendations(analysis: dict[str, object], available: list[str], installed: list[str]) -> list[dict[str, str]]:
+    result: list[dict[str, str]] = []
+    if "booking" in available and "booking" not in installed:
+        if analysis.get("sellsServices"):
+            notes = []
+            if not any(name in {"pg", "postgres", "@neondatabase/serverless"} for name in analysis.get("database", [])):
+                notes.append("it needs PostgreSQL, which this project does not use yet")
+            if analysis.get("auth"):
+                notes.append(f"the site already signs people in with {', '.join(analysis['auth'])}; MaggieDash keeps its own staff sign-in")
+            reason = "The site offers appointments or services (" + ", ".join(analysis.get("serviceEvidence", [])[:3]) + ")" + ("; " + "; ".join(notes) if notes else "")
+            result.append({"kind": "module", "module": "booking", "recommended": "yes", "reason": reason, "command": "maggie dash add booking --confirm"})
+        else:
+            result.append({"kind": "module", "module": "booking", "recommended": "no", "reason": "No appointments or bookable services found in src/; add it only if the business takes bookings.", "command": "maggie dash add booking --confirm"})
+    if analysis.get("blog"):
+        result.append({"kind": "skill", "skill": "maggie-blog", "recommended": "yes", "reason": "The site has a blog; manage posts from the dashboard Blog panel.", "command": "use the maggie-blog skill"})
+        result.append({"kind": "skill", "skill": "maggie-social-share", "recommended": "maybe", "reason": "Blog posts can be shared to social channels after publishing.", "command": "use the maggie-social-share skill"})
+    else:
+        result.append({"kind": "skill", "skill": "maggie-blog-bootstrap", "recommended": "maybe", "reason": "No blog found; add one only if the site will publish articles.", "command": "use the maggie-blog-bootstrap skill"})
+    if len(analysis.get("locales", [])) > 1:
+        result.append({"kind": "skill", "skill": "maggie-content-localization", "recommended": "yes", "reason": f"The site serves {', '.join(analysis['locales'])}; keep translations in the Languages panel.", "command": "use the maggie-content-localization skill"})
+    return result
+
+
 def command_install_diff(source: Path, manifest: dict[str, object], target: Path, compare_dir: Path | None, force: bool, host_pairs: list[tuple[Path, Path, Path]] | None = None, host_framework: str | None = None) -> dict[str, object]:
     pairs = manifest_file_pairs(source, manifest, target)
     root_pairs = manifest_root_file_pairs(source, manifest, target.parents[1])
@@ -386,7 +510,16 @@ def command_install(args: argparse.Namespace) -> int:
             raise RuntimeError("unsupported MaggieDash distribution schema")
         if manifest.get("target") != "_maggie/admin" and args.target == "_maggie/admin":
             raise RuntimeError("MaggieDash manifest target is not ./_maggie/admin")
+        previous = installed_state(root)
+        legacy = not module_names(manifest)
+        modules = resolve_modules(manifest, list(getattr(args, "with_modules", None) or []) + (module_names(manifest) if getattr(args, "all_modules", False) else []), [name for name in previous.get("modules", []) if name != CORE_MODULE])
+        module_specs = manifest.get("modules") if isinstance(manifest.get("modules"), dict) else {}
+        manifest = effective_manifest(manifest, modules)
         host_pairs = manifest_host_file_pairs(source, manifest, root, host_framework)
+        for name in modules:
+            host_pairs += manifest_host_file_pairs(source, module_specs[name], root, host_framework, required=False)
+        analysis = analyse_host(root, host_framework)
+        advice = recommendations(analysis, module_names({"modules": module_specs}), modules)
         compare_dir = None
         if args.existing_dir:
             compare_dir = Path(args.existing_dir).expanduser()
@@ -394,7 +527,9 @@ def command_install(args: argparse.Namespace) -> int:
                 compare_dir = root / compare_dir
             compare_dir = compare_dir.resolve()
         if args.dry_run or args.diff:
-            emit(command_install_diff(source, manifest, target, compare_dir, args.force, host_pairs, host_framework))
+            plan = command_install_diff(source, manifest, target, compare_dir, args.force, host_pairs, host_framework)
+            plan.update({"modules": [CORE_MODULE, *modules] if not legacy else ["all (release without modules)"], "availableModules": module_names({"modules": module_specs}), "host": analysis, "recommendations": advice})
+            emit(plan)
             return 0
         installed: list[str] = []
         preserved: list[str] = []
@@ -471,18 +606,39 @@ def command_install(args: argparse.Namespace) -> int:
             "hostPreserved": sorted(set(host_preserved)),
             "hostUpdated": sorted(set(host_updated)),
             "hostWarnings": sorted(set(host_warnings)),
+            "modules": [CORE_MODULE, *modules] if not legacy else ["legacy-all"],
             "updatedAt": utc_now(),
         }
         state_path = root / ".maggie" / "dash-install.json"
         state_path.parent.mkdir(parents=True, exist_ok=True)
         state_path.write_text(json.dumps(state, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
-        emit({"status": "needs-attention" if host_warnings else "installed", "version": manifest.get("version"), "target": str(target), "hostFramework": host_framework, "hostInstalled": len(set(host_installed)), "hostPreserved": len(set(host_preserved)), "hostUpdated": len(set(host_updated)), "hostWarnings": host_warnings, "installed": len(set(installed)), "preserved": len(set(preserved)), "state": str(state_path)})
+        notices = ["this MaggieDash release has no module split, so its Booking workspace was installed with the core; use MaggieDash 0.2.14 or later to install the core first"] if legacy and manifest.get("workspaces") else []
+        emit({"status": "needs-attention" if host_warnings else "installed", "version": manifest.get("version"), "modules": state["modules"], "notices": notices, "recommendations": advice, "next": "Add a recommended module with `maggie dash add <module> --confirm`; nothing optional is installed without that step." if advice and not legacy else None, "target": str(target), "hostFramework": host_framework, "hostInstalled": len(set(host_installed)), "hostPreserved": len(set(host_preserved)), "hostUpdated": len(set(host_updated)), "hostWarnings": host_warnings, "installed": len(set(installed)), "preserved": len(set(preserved)), "state": str(state_path)})
         return 1 if host_warnings else 0
     finally:
         if temporary is not None:
             temporary.cleanup()
 
 
+def command_add(args: argparse.Namespace) -> int:
+    """Install one optional module next to an existing (or new) core install."""
+    args.with_modules = list(args.modules)
+    args.all_modules = False
+    return command_install(args)
+
+
+def command_recommend(args: argparse.Namespace) -> int:
+    root = project_root(args)
+    framework = detect_host_framework(root, args.host)
+    state = installed_state(root)
+    installed = [name for name in state.get("modules", []) if name != CORE_MODULE]
+    analysis = analyse_host(root, framework)
+    # The module list comes from the installed release when known; Booking is
+    # the optional code module MaggieDash ships today.
+    emit({"status": "recommendations", "installed": state.get("modules", []), "host": analysis, "recommendations": recommendations(analysis, ["booking"], installed)})
+    return 0
+
+
 def command_init(args: argparse.Namespace) -> int:
     require_confirm(args)
     root = project_root(args)
@@ -832,8 +988,22 @@ def parser() -> argparse.ArgumentParser:
     install.add_argument("--dry-run", action="store_true", help="show the install plan without writing files")
     install.add_argument("--diff", action="store_true", help="show the install plan and compare with an existing workspace")
     install.add_argument("--existing-dir", help="existing dashboard source directory to compare during --diff")
+    install.add_argument("--with", dest="with_modules", action="append", default=[], metavar="MODULE", help="also install an optional module (repeatable), e.g. --with booking")
+    install.add_argument("--all-modules", action="store_true", help="install every optional module (the pre-0.2.14 behaviour)")
     install.add_argument("--confirm", action="store_true")
     install.set_defaults(func=command_install)
+    add = sub.add_parser("add", help="add an optional MaggieDash module (e.g. booking) to an installed core")
+    add.add_argument("modules", nargs="+", metavar="MODULE")
+    for flag, options in (("--project", {"default": "."}), ("--source", {"help": "local checkout or Git URL; defaults to MaggieDash repository"}), ("--ref", {"default": "main"}), ("--target", {"default": "_maggie/admin"}), ("--existing-dir", {})):
+        add.add_argument(flag, **options)
+    add.add_argument("--host", choices=["auto", "astro", "none"], default="auto")
+    for flag in ("--force", "--dry-run", "--diff", "--confirm"):
+        add.add_argument(flag, action="store_true")
+    add.set_defaults(func=command_add)
+    recommend = sub.add_parser("recommend", help="analyse the host project and recommend optional modules and skills")
+    recommend.add_argument("--project", default=".")
+    recommend.add_argument("--host", choices=["auto", "astro", "none"], default="auto")
+    recommend.set_defaults(func=command_recommend)
     status = sub.add_parser("status", help="inspect project and documents")
     status.add_argument("--project", default=".")
     status.add_argument("--project-id")