@adia-ai/mcp 0.8.37 → 0.8.39

package/factory/vendor/adia-info

@@ -0,0 +1,312 @@
+#!/usr/bin/env python3
+"""adia-info — one-shot project-context probe for adia-ui consumer repos.
+
+Prints a compact JSON snapshot of the facts the factory skills otherwise
+re-discover by hand every session: which @adia-ai/* packages the project
+declares (and which version is actually installed), the rendering-mode and
+framework signals app-planning's classifiers cite, which shells the source
+uses, theming setup, MCP wiring, and whether the cwd is actually the
+framework monorepo itself (a misroute signal — that work belongs to the
+adia-ui-forge plugin).
+
+Designed for dynamic context injection from a SKILL.md body:
+
+    !`python3 "${CLAUDE_PLUGIN_ROOT}/scripts/adia-info"`
+
+so every field carries the SIGNAL it was derived from (file path or dep
+name) — a skill consuming this output can cite signals per app-planning's
+evidence gate instead of asserting axes bare.
+
+Contract: NEVER exits non-zero, never prints to stderr on the happy path —
+a context-injection command that fails or noises breaks the skill it feeds.
+Any probe error degrades that field to null with the error noted in
+`probeErrors`. Bounded: scans at most MAX_SCAN_FILES source files, skipping
+node_modules/dist/.git.
+
+Usage:
+  adia-info [dir]              # probe dir (default: cwd); print JSON to stdout
+  adia-info [dir] --staleness  # ALSO query npm for latest (network; never default)
+  adia-info selftest           # run built-in fixtures; exit 0 iff all pass
+Stdlib only (Python 3.8+).
+"""
+import json
+import os
+import re
+import sys
+
+MAX_SCAN_FILES = 400
+SOURCE_EXTS = (".html", ".js", ".mjs", ".ts", ".jsx", ".tsx", ".css")
+SKIP_DIRS = {"node_modules", "dist", ".git", ".next", ".nuxt", ".svelte-kit", "build", "coverage"}
+
+SSR_FRAMEWORKS = {  # dep name -> framework label
+    "next": "next", "nuxt": "nuxt", "@sveltejs/kit": "sveltekit", "astro": "astro",
+}
+SHELL_TAGS = ("admin-shell", "chat-shell", "editor-shell", "simple-shell", "embed-shell")
+
+
+def _read_json(path):
+    try:
+        with open(path, encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return None
+
+
+def _iter_source_files(root):
+    count = 0
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = [d for d in dirnames if d not in SKIP_DIRS and not d.startswith(".")]
+        for name in filenames:
+            if name.endswith(SOURCE_EXTS):
+                yield os.path.join(dirpath, name)
+                count += 1
+                if count >= MAX_SCAN_FILES:
+                    return
+
+
+def probe(root):
+    info = {"probeRoot": os.path.abspath(root), "probeErrors": []}
+
+    # ── package.json: adia deps, framework, package manager ──
+    pkg = _read_json(os.path.join(root, "package.json")) or {}
+    deps = {}
+    for key in ("dependencies", "devDependencies"):
+        deps.update(pkg.get(key) or {})
+    info["adiaPackages"] = {k: v for k, v in sorted(deps.items()) if k.startswith("@adia-ai/")}
+
+    installed = _read_json(os.path.join(root, "node_modules", "@adia-ai", "web-components", "package.json"))
+    info["installedVersion"] = installed.get("version") if installed else None
+
+    # ── split-lockstep detection (offline): all installed @adia-ai/* versions ──
+    # The 11 @adia-ai packages version in lockstep upstream; a consumer whose
+    # installed copies diverge (partial upgrade, stale lockfile entry) sees
+    # cross-package breakage that presents as component bugs.
+    installed_versions = {}
+    adia_dir = os.path.join(root, "node_modules", "@adia-ai")
+    if os.path.isdir(adia_dir):
+        for name in sorted(os.listdir(adia_dir)):
+            p = _read_json(os.path.join(adia_dir, name, "package.json"))
+            if p and p.get("version"):
+                installed_versions[f"@adia-ai/{name}"] = p["version"]
+    distinct = sorted(set(installed_versions.values()))
+    info["installedAdiaVersions"] = installed_versions or None
+    info["splitLockstep"] = (
+        {"value": len(distinct) > 1, "versions": distinct,
+         "signal": "node_modules/@adia-ai/*/package.json version fields"}
+        if installed_versions else None
+    )
+
+    framework = next((label for dep, label in SSR_FRAMEWORKS.items() if dep in deps), None)
+    if framework is None and "vite" in deps:
+        framework = "vite"
+    info["framework"] = framework
+
+    pm = pkg.get("packageManager")
+    if pm:
+        info["packageManager"] = {"value": pm.split("@")[0], "signal": "package.json packageManager field"}
+    else:
+        for lockfile, name in (("pnpm-lock.yaml", "pnpm"), ("bun.lockb", "bun"), ("bun.lock", "bun"),
+                               ("yarn.lock", "yarn"), ("package-lock.json", "npm")):
+            if os.path.exists(os.path.join(root, lockfile)):
+                info["packageManager"] = {"value": name, "signal": lockfile}
+                break
+        else:
+            info["packageManager"] = None
+
+    # ── framework-monorepo misroute signal ──
+    info["isFrameworkMonorepo"] = (
+        os.path.isdir(os.path.join(root, "packages", "web-components", "components"))
+        and os.path.isdir(os.path.join(root, "packages", "a2ui"))
+    )
+
+    # ── rendering mode (app-planning classifier 1, same signals) ──
+    if framework in SSR_FRAMEWORKS.values():
+        route_dirs = [d for d in ("app", "pages", "src/routes", "src/pages") if os.path.isdir(os.path.join(root, d))]
+        info["renderingMode"] = {"value": "ssr", "signal": f"{framework} in package.json" + (f" + {route_dirs[0]}/" if route_dirs else "")}
+    elif info["adiaPackages"] or os.path.exists(os.path.join(root, "index.html")):
+        info["renderingMode"] = {"value": "spa", "signal": "no SSR framework dep" + ("; index.html present" if os.path.exists(os.path.join(root, "index.html")) else "")}
+    else:
+        info["renderingMode"] = {"value": "unknown", "signal": "no package.json deps or index.html found"}
+
+    # ── source scan: shells, registration, theming, custom tags ──
+    shells, register_files, theme = set(), [], {"themesCss": False, "dataScheme": False, "namedTheme": False}
+    scanned = 0
+    try:
+        for path in _iter_source_files(root):
+            scanned += 1
+            try:
+                with open(path, encoding="utf-8", errors="ignore") as f:
+                    text = f.read()
+            except Exception:
+                continue
+            for tag in SHELL_TAGS:
+                if "<" + tag in text or "adia-" + tag in text:
+                    shells.add(tag)
+            if "@adia-ai/web-components" in text or "@adia-ai/web-modules" in text:
+                register_files.append(os.path.relpath(path, root))
+            if "themes.css" in text:
+                theme["themesCss"] = True
+            if "data-scheme" in text:
+                theme["dataScheme"] = True
+            if re.search(r'\btheme="[a-z]', text):
+                theme["namedTheme"] = True
+    except Exception as e:  # pragma: no cover — never let a scan error kill the probe
+        info["probeErrors"].append(f"source scan: {e}")
+    info["shellsUsed"] = sorted(shells)
+    info["registrationFiles"] = sorted(register_files)[:10]
+    info["theme"] = theme
+    info["scannedFiles"] = scanned
+
+    # ── MCP wiring ──
+    mcp = _read_json(os.path.join(root, ".mcp.json"))
+    servers = (mcp or {}).get("mcpServers") or {}
+    a2ui = next((v for k, v in servers.items() if "a2ui" in k), None)
+    if a2ui:
+        args = " ".join(a2ui.get("args") or [])
+        pin = re.search(r"@adia-ai/a2ui-mcp@([\w.\-]+)", args)
+        info["a2uiMcp"] = {"configured": True, "pin": pin.group(1) if pin else None}
+    else:
+        info["a2uiMcp"] = {"configured": False, "pin": None}
+
+    info["typescript"] = os.path.exists(os.path.join(root, "tsconfig.json"))
+    return info
+
+
+def _selftest():
+    import shutil
+    import tempfile
+
+    failures = []
+
+    def check(name, cond):
+        if not cond:
+            failures.append(name)
+
+    # Fixture 1: SPA consumer with adia deps, shells, theme, MCP pin.
+    tmp = tempfile.mkdtemp(prefix="adia-info-spa-")
+    try:
+        with open(os.path.join(tmp, "package.json"), "w") as f:
+            json.dump({"dependencies": {"@adia-ai/web-components": "^0.8.0", "vite": "^5.0.0"}}, f)
+        with open(os.path.join(tmp, "package-lock.json"), "w") as f:
+            f.write("{}")
+        with open(os.path.join(tmp, "index.html"), "w") as f:
+            f.write('<html data-scheme="dark" theme="ocean"><link href="themes.css">'
+                    '<script type="module">import "@adia-ai/web-components";</script>'
+                    "<admin-shell></admin-shell></html>")
+        with open(os.path.join(tmp, ".mcp.json"), "w") as f:
+            json.dump({"mcpServers": {"a2ui": {"args": ["-y", "@adia-ai/a2ui-mcp@0.8.0"]}}}, f)
+        r = probe(tmp)
+        check("spa: mode", r["renderingMode"]["value"] == "spa")
+        check("spa: adia dep", "@adia-ai/web-components" in r["adiaPackages"])
+        check("spa: framework vite", r["framework"] == "vite")
+        check("spa: pm npm via lockfile", r["packageManager"] == {"value": "npm", "signal": "package-lock.json"})
+        check("spa: shell found", r["shellsUsed"] == ["admin-shell"])
+        check("spa: registration file", r["registrationFiles"] == ["index.html"])
+        check("spa: theme trio", r["theme"] == {"themesCss": True, "dataScheme": True, "namedTheme": True})
+        check("spa: mcp pin", r["a2uiMcp"] == {"configured": True, "pin": "0.8.0"})
+        check("spa: not monorepo", r["isFrameworkMonorepo"] is False)
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+    # Fixture 2: SSR (next) consumer.
+    tmp = tempfile.mkdtemp(prefix="adia-info-ssr-")
+    try:
+        with open(os.path.join(tmp, "package.json"), "w") as f:
+            json.dump({"dependencies": {"next": "15.0.0", "@adia-ai/web-components": "^0.8.0"},
+                       "packageManager": "pnpm@9.0.0"}, f)
+        os.makedirs(os.path.join(tmp, "app"))
+        r = probe(tmp)
+        check("ssr: mode", r["renderingMode"]["value"] == "ssr")
+        check("ssr: signal cites next", "next" in r["renderingMode"]["signal"])
+        check("ssr: pm field wins", r["packageManager"]["value"] == "pnpm")
+        check("ssr: mcp unconfigured", r["a2uiMcp"]["configured"] is False)
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+    # Fixture 3: empty dir never crashes, mode unknown.
+    tmp = tempfile.mkdtemp(prefix="adia-info-empty-")
+    try:
+        r = probe(tmp)
+        check("empty: mode unknown", r["renderingMode"]["value"] == "unknown")
+        check("empty: no errors", r["probeErrors"] == [])
+        json.dumps(r)  # must be serializable
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+    # Fixture 4 (gh#1122, REQ-06): -h/--help must print usage and exit 0 —
+    # NEVER silently probe a literal "-h" directory and return a degenerate
+    # JSON payload with exit 0 (the actual repro this fixture locks shut).
+    import contextlib
+    import io
+    for flag in ("-h", "--help"):
+        buf = io.StringIO()
+        with contextlib.redirect_stdout(buf):
+            rc = main(["adia-info", flag])
+        out = buf.getvalue()
+        check(f"help: {flag} exits 0", rc == 0)
+        check(f"help: {flag} prints usage", out.startswith("usage:"))
+        check(f"help: {flag} is not a JSON probe payload", "probeRoot" not in out)
+
+    if failures:
+        print("selftest FAIL: " + ", ".join(failures), file=sys.stderr)
+        return 1
+    print("selftest OK — 4 fixtures")
+    return 0
+
+
+def _probe_staleness(info):
+    """Opt-in (--staleness): compare installed web-components against npm latest.
+
+    Network + subprocess, so NEVER part of the default probe — the default
+    output feeds skill-load context injection and must stay offline-fast.
+    Fail-soft like every other field."""
+    import subprocess
+    try:
+        out = subprocess.run(
+            ["npm", "view", "@adia-ai/web-components", "version"],
+            capture_output=True, text=True, timeout=10,
+        )
+        if out.returncode != 0:
+            raise RuntimeError((out.stderr or out.stdout or "npm view exited nonzero").strip())
+        latest = out.stdout.strip() or None
+        info["npmLatest"] = latest
+        installed = info.get("installedVersion")
+        info["staleInstall"] = (
+            {"value": installed != latest, "installed": installed, "latest": latest,
+             "signal": "npm view @adia-ai/web-components version"}
+            if latest and installed else None
+        )
+    except Exception as e:
+        info["npmLatest"] = None
+        info["staleInstall"] = None
+        info["probeErrors"].append(f"staleness: {e}")
+
+
+def main(argv):
+    rest = argv[1:]
+    # REQ-06 (gh#1122): -h/--help must print usage and exit 0 BEFORE any
+    # positional/root resolution — the bug was that only "--"-prefixed
+    # tokens were filtered into `flags`, so single-dash "-h" fell through
+    # into `args` and became `root`, silently probing a literal directory
+    # named "-h". Checked first, in any position, so it can never fall
+    # through regardless of what else is on the command line.
+    if any(a in ("-h", "--help") for a in rest):
+        print("usage: adia-info [dir] [--staleness]   probe an adia-ui consumer app (default: cwd)")
+        return 0
+    if rest and rest[0] == "selftest":
+        return _selftest()
+    args = [a for a in rest if not a.startswith("-")]
+    flags = {a for a in rest if a.startswith("-")}
+    root = args[0] if args else "."
+    try:
+        info = probe(root)
+        if "--staleness" in flags:
+            _probe_staleness(info)
+        print(json.dumps(info, indent=1))
+    except Exception as e:  # ultimate fail-soft: emit the error as JSON, exit 0
+        print(json.dumps({"probeErrors": [str(e)]}))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))