@idia-ui/cli 0.2.0

package/dist/cli.js

@@ -0,0 +1,1602 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_commander = require("commander");
+var import_node_path10 = require("path");
+
+// src/commands/storybook/add.ts
+var import_node_fs5 = require("fs");
+var import_node_path5 = require("path");
+var import_node_child_process = require("child_process");
+
+// src/commands/storybook/constants.ts
+var STORYBOOK_DOCS_VERSION = "0.2.0";
+var STORYBOOK_PRESET_VERSION = "0.2.0";
+var STORYBOOK_CLI_VERSION = "8.4.7";
+var STORYBOOK_DEV_DEPS = [
+  "storybook@^8.4.7",
+  "@storybook/react-vite@^8.4.7",
+  "@storybook/addon-docs@^8.4.7",
+  "@storybook/addon-a11y@^8.4.7",
+  "@storybook/addon-links@^8.4.7",
+  `@idia-ui/storybook-docs@${STORYBOOK_DOCS_VERSION}`,
+  `@idia-ui/storybook-preset-react-native-web@${STORYBOOK_PRESET_VERSION}`,
+  "vite@^5.4.0",
+  "vite-tsconfig-paths@^4.3.0"
+];
+var STORYBOOK_OWNED_FILES = [
+  ".storybook/main.ts",
+  ".storybook/preview.tsx",
+  "src/stories/Button.stories.tsx"
+];
+
+// src/commands/storybook/templates.ts
+function storybookMainTs() {
+  return `import type { StorybookConfig } from '@storybook/react-vite';
+import { idiaStorybookMain } from '@idia-ui/storybook-preset-react-native-web';
+
+const config: StorybookConfig = idiaStorybookMain({
+  stories: ['../src/stories/**/*.stories.@(ts|tsx)'],
+  staticDirs: ['../public'],
+});
+
+export default config;
+`;
+}
+function storybookPreviewTsx() {
+  return `import React from 'react';
+import type { Preview } from '@storybook/react';
+import { AppProviders } from '../src/providers/AppProviders';
+import '../global.css';
+
+const preview: Preview = {
+  decorators: [
+    (Story) => (
+      <AppProviders>
+        <Story />
+      </AppProviders>
+    ),
+  ],
+  parameters: {
+    layout: 'centered',
+    controls: { expanded: true },
+  },
+};
+
+export default preview;
+`;
+}
+function buttonStoriesTsx() {
+  return `import type { Meta, StoryObj } from '@storybook/react';
+import { Button } from '@idia-ui/core';
+import { BrainDocSections } from '@idia-ui/storybook-docs';
+
+const meta = {
+  title: 'Components/Button',
+  component: Button,
+  tags: ['autodocs'],
+  parameters: {
+    docs: {
+      page: () => (
+        <>
+          <BrainDocSections
+            componentId="button"
+            sectionIds={['intent', 'usage', 'variants', 'accessibility']}
+          />
+        </>
+      ),
+    },
+  },
+  args: {
+    label: 'Button',
+    variant: 'primary',
+  },
+} satisfies Meta<typeof Button>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Playground: Story = {};
+`;
+}
+
+// src/utils/pm.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+function findLockfileDir(start) {
+  let dir = start;
+  while (true) {
+    if ((0, import_node_fs.existsSync)((0, import_node_path.join)(dir, "pnpm-lock.yaml"))) return dir;
+    if ((0, import_node_fs.existsSync)((0, import_node_path.join)(dir, "yarn.lock"))) return dir;
+    if ((0, import_node_fs.existsSync)((0, import_node_path.join)(dir, "package-lock.json"))) return dir;
+    const parent = (0, import_node_path.dirname)(dir);
+    if (parent === dir) return start;
+    dir = parent;
+  }
+}
+function detectPackageManager(cwd) {
+  const root = findLockfileDir(cwd);
+  if ((0, import_node_fs.existsSync)((0, import_node_path.join)(root, "pnpm-lock.yaml"))) return "pnpm";
+  if ((0, import_node_fs.existsSync)((0, import_node_path.join)(root, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+function pmAddCommand(pm, packages) {
+  const list = packages.join(" ");
+  switch (pm) {
+    case "pnpm":
+      return `pnpm add ${list}`;
+    case "yarn":
+      return `yarn add ${list}`;
+    default:
+      return `npm install ${list}`;
+  }
+}
+
+// src/utils/package-json.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+function readPackageJson(cwd) {
+  try {
+    const raw = (0, import_node_fs2.readFileSync)((0, import_node_path2.join)(cwd, "package.json"), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function getDepVersion(pkg, name) {
+  return pkg.dependencies?.[name] ?? pkg.devDependencies?.[name];
+}
+function readInstalledVersion(cwd, name) {
+  try {
+    const pkgPath = (0, import_node_path2.join)(cwd, "node_modules", name, "package.json");
+    const raw = (0, import_node_fs2.readFileSync)(pkgPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed.version ?? null;
+  } catch {
+    return null;
+  }
+}
+function readPeerRange(cwd, packageName, peerName) {
+  try {
+    const pkgPath = (0, import_node_path2.join)(cwd, "node_modules", packageName, "package.json");
+    const raw = (0, import_node_fs2.readFileSync)(pkgPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed.peerDependencies?.[peerName] ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// src/utils/fs.ts
+var import_node_fs3 = require("fs");
+var import_node_path3 = require("path");
+var import_semver = __toESM(require("semver"));
+function satisfiesRange(version, range) {
+  const cleaned = version.replace(/^[\^~>=<]*/, "").split(" ")[0] ?? version;
+  if (range === "workspace:*" || range.startsWith("file:")) return true;
+  const coerced = import_semver.default.coerce(cleaned);
+  if (!coerced) return false;
+  return import_semver.default.satisfies(coerced, range, { includePrerelease: true });
+}
+function getMinor(version) {
+  const coerced = import_semver.default.coerce(version);
+  if (!coerced) return null;
+  return `${coerced.major}.${coerced.minor}`;
+}
+function readTextFile(cwd, relativePath) {
+  try {
+    return (0, import_node_fs3.readFileSync)((0, import_node_path3.join)(cwd, relativePath), "utf8");
+  } catch {
+    return null;
+  }
+}
+function fileExists(cwd, relativePath) {
+  try {
+    return (0, import_node_fs3.existsSync)((0, import_node_path3.join)(cwd, relativePath));
+  } catch {
+    return false;
+  }
+}
+function grepSrcForPattern(cwd, pattern) {
+  const filesToScan = [
+    "App.tsx",
+    "src/providers/AppProviders.tsx"
+  ];
+  for (const file of filesToScan) {
+    const content = readTextFile(cwd, file);
+    if (content && pattern.test(content)) return true;
+  }
+  const srcRoot = (0, import_node_path3.join)(cwd, "src");
+  try {
+    const walk = (dir) => {
+      for (const entry of (0, import_node_fs3.readdirSync)(dir)) {
+        const full = (0, import_node_path3.join)(dir, entry);
+        const stat = (0, import_node_fs3.statSync)(full);
+        if (stat.isDirectory()) {
+          if (walk(full)) return true;
+        } else if (/\.(tsx?|jsx?)$/.test(entry)) {
+          const content = (0, import_node_fs3.readFileSync)(full, "utf8");
+          if (pattern.test(content)) return true;
+        }
+      }
+      return false;
+    };
+    if ((0, import_node_fs3.existsSync)(srcRoot)) return walk(srcRoot);
+  } catch {
+  }
+  return false;
+}
+
+// src/utils/manifest.ts
+var import_node_fs4 = require("fs");
+var import_node_path4 = require("path");
+var CLI_VERSION = "0.2.0";
+function readManifest(cwd) {
+  try {
+    const raw = (0, import_node_fs4.readFileSync)((0, import_node_path4.join)(cwd, ".idia", "manifest.json"), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function writeManifest(cwd, manifest) {
+  const manifestPath = (0, import_node_path4.join)(cwd, ".idia", "manifest.json");
+  (0, import_node_fs4.mkdirSync)((0, import_node_path4.dirname)(manifestPath), { recursive: true });
+  (0, import_node_fs4.writeFileSync)(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+}
+function regenerateManifest(cwd, coreVersion) {
+  const manifestPath = (0, import_node_path4.join)(cwd, ".idia", "manifest.json");
+  const manifest = {
+    idiaCli: CLI_VERSION,
+    core: coreVersion
+  };
+  writeManifest(cwd, manifest);
+  return { created: true, path: manifestPath };
+}
+function manifestExists(cwd) {
+  return fileExists(cwd, ".idia/manifest.json");
+}
+function validateManifestShape(manifest) {
+  return typeof manifest.idiaCli === "string" && typeof manifest.core === "string" && /^\d+\.\d+\.\d+/.test(manifest.idiaCli) && /^\d+\.\d+\.\d+/.test(manifest.core);
+}
+
+// src/commands/storybook/add.ts
+function writeOwnedFile(cwd, relativePath, content, force) {
+  const fullPath = (0, import_node_path5.join)(cwd, relativePath);
+  if (fileExists(cwd, relativePath) && !force) {
+    const existing = readTextFile(cwd, relativePath);
+    if (existing === content) return false;
+    throw new Error(
+      `Conflict: ${relativePath} exists with different content. Use --repair or --force.`
+    );
+  }
+  (0, import_node_fs5.mkdirSync)((0, import_node_path5.dirname)(fullPath), { recursive: true });
+  (0, import_node_fs5.writeFileSync)(fullPath, content, "utf8");
+  return true;
+}
+function parseDepSpec(spec) {
+  if (spec.startsWith("@")) {
+    const at2 = spec.indexOf("@", 1);
+    return { name: spec.slice(0, at2), range: spec.slice(at2 + 1) };
+  }
+  const at = spec.indexOf("@");
+  return { name: spec.slice(0, at), range: spec.slice(at + 1) };
+}
+function resolveDepVersion(name, range) {
+  if (name.startsWith("@idia-ui/storybook")) {
+    return "workspace:*";
+  }
+  return `^${range.replace(/^\^/, "")}`;
+}
+function addDevDependencies(cwd) {
+  const pkg = readPackageJson(cwd);
+  if (!pkg) throw new Error("package.json not found");
+  pkg.devDependencies ??= {};
+  for (const spec of STORYBOOK_DEV_DEPS) {
+    const { name, range } = parseDepSpec(spec);
+    pkg.devDependencies[name] = resolveDepVersion(name, range);
+  }
+  pkg.scripts ??= {};
+  pkg.scripts.storybook = "storybook dev -p 6006";
+  pkg.scripts["build-storybook"] = "storybook build";
+  (0, import_node_fs5.writeFileSync)((0, import_node_path5.join)(cwd, "package.json"), `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+}
+function runPmInstall(cwd, pm) {
+  const args = pm === "pnpm" ? ["add", "-D", ...STORYBOOK_DEV_DEPS] : pm === "yarn" ? ["add", "-D", ...STORYBOOK_DEV_DEPS] : ["install", "-D", ...STORYBOOK_DEV_DEPS];
+  const result = (0, import_node_child_process.spawnSync)(pm, args, {
+    cwd,
+    stdio: "inherit",
+    shell: process.platform === "win32"
+  });
+  if (result.status !== 0) {
+    throw new Error(`${pm} install failed with exit code ${result.status ?? "unknown"}`);
+  }
+}
+function resolveCoreVersion(cwd, pkg) {
+  const installed = readInstalledVersion(cwd, "@idia-ui/core");
+  if (installed) return installed;
+  const declared = pkg.dependencies?.["@idia-ui/core"] ?? "";
+  if (declared && !declared.startsWith("workspace")) {
+    return declared.replace(/^[\^~]/, "");
+  }
+  return "0.2.0";
+}
+function updateStorybookManifest(cwd, manifest, coreVersion) {
+  manifest.idiaCli = CLI_VERSION;
+  manifest.core = coreVersion;
+  manifest.features ??= {};
+  manifest.features.storybook = {
+    installed: (/* @__PURE__ */ new Date()).toISOString(),
+    storybookDocs: STORYBOOK_DOCS_VERSION,
+    storybook: STORYBOOK_CLI_VERSION,
+    preset: STORYBOOK_PRESET_VERSION
+  };
+  writeManifest(cwd, manifest);
+}
+function isStorybookInstalled(cwd) {
+  return fileExists(cwd, ".storybook/main.ts") && Boolean(readPackageJson(cwd)?.devDependencies?.["@idia-ui/storybook-docs"]);
+}
+function runAddStorybook(options) {
+  const { cwd, repair = false, force = false, skipInstall = false } = options;
+  const pm = options.pm ?? detectPackageManager(cwd);
+  const warnings = [];
+  const filesWritten = [];
+  const pkg = readPackageJson(cwd);
+  if (!pkg) {
+    console.error("package.json not found \u2014 run from your app root");
+    process.exit(1);
+  }
+  let manifest = readManifest(cwd);
+  const coreVersion = resolveCoreVersion(cwd, pkg);
+  if (!manifest) {
+    manifest = { idiaCli: CLI_VERSION, core: coreVersion };
+    warnings.push("Created .idia/manifest.json stub");
+  } else {
+    manifest.core = coreVersion;
+  }
+  const alreadyInstalled = isStorybookInstalled(cwd);
+  if (alreadyInstalled && !repair && !force) {
+    console.log("Storybook already installed \u2014 idempotent skip (use --repair to refresh CLI-owned files)");
+    updateStorybookManifest(cwd, manifest, coreVersion);
+    return { installed: true, alreadyInstalled: true, filesWritten, warnings };
+  }
+  const ownedContent = {
+    ".storybook/main.ts": storybookMainTs(),
+    ".storybook/preview.tsx": storybookPreviewTsx(),
+    "src/stories/Button.stories.tsx": buttonStoriesTsx()
+  };
+  for (const relativePath of STORYBOOK_OWNED_FILES) {
+    if (repair || force || !fileExists(cwd, relativePath)) {
+      const wrote = writeOwnedFile(cwd, relativePath, ownedContent[relativePath], force || repair);
+      if (wrote) filesWritten.push(relativePath);
+    }
+  }
+  addDevDependencies(cwd);
+  if (!skipInstall) {
+    console.log(`Installing Storybook devDependencies via ${pm}\u2026`);
+    runPmInstall(cwd, pm);
+  } else {
+    warnings.push("Skipped package manager install (--skip-install)");
+  }
+  updateStorybookManifest(cwd, manifest, coreVersion);
+  console.log("\n\u2713 Storybook add-on installed");
+  console.log(`  @idia-ui/storybook-docs@${STORYBOOK_DOCS_VERSION}`);
+  console.log(`  @idia-ui/storybook-preset-react-native-web@${STORYBOOK_PRESET_VERSION}`);
+  console.log("  Run: pnpm storybook (or npm run storybook)");
+  return { installed: true, alreadyInstalled, filesWritten, warnings };
+}
+
+// src/brain/install.ts
+var import_node_fs8 = require("fs");
+var import_node_path8 = require("path");
+
+// src/brain/agents-patch.ts
+var import_node_fs6 = require("fs");
+var import_node_path6 = require("path");
+
+// src/brain/constants.ts
+var BRAIN_PACK_NAME = "@idia-ui/brain-pack";
+var BRAIN_PACK_VERSION = "0.2.0";
+var BRAIN_TIER_DISCLAIMER = "@idia-ui/brain-pack is a generated AI retrieval pack for idia-ui usage guidance. It does not imply Tier 1 passive external-agent graduation, GA readiness, or full-catalog efficacy.";
+var BRAIN_DOCTOR_DISCLAIMER = "brain pack is experimental retrieval guidance; it does not imply Tier 1P graduation";
+var AGENTS_BEGIN = "<!-- idia-ui brain:begin -->";
+var AGENTS_END = "<!-- idia-ui brain:end -->";
+var AGENTS_BRAIN_BLOCK = `${AGENTS_BEGIN}
+## idia-ui design-system brain
+
+For idia-ui component usage, design-system documentation, Storybook docs, UI generation, or AI-guided UI work, read:
+
+\`.idia/brain/AGENTS.md\`
+
+before using idia-ui components.
+
+This installed brain pack is read-only generated guidance. Do not edit files under \`.idia/brain/\` directly.
+${AGENTS_END}`;
+
+// src/brain/agents-patch.ts
+function patchRootAgentsMd(cwd, options) {
+  const agentsPath = (0, import_node_path6.join)(cwd, "AGENTS.md");
+  const existing = readTextFile(cwd, "AGENTS.md");
+  if (existing === null) {
+    (0, import_node_fs6.writeFileSync)(agentsPath, `${AGENTS_BRAIN_BLOCK}
+`, "utf8");
+    return { status: "created" };
+  }
+  const hasBegin = existing.includes(AGENTS_BEGIN);
+  const hasEnd = existing.includes(AGENTS_END);
+  if (hasBegin && hasEnd) {
+    if (!options.repair && !options.force) {
+      return { status: "merged" };
+    }
+    const updated = existing.replace(
+      new RegExp(`${escapeRegExp(AGENTS_BEGIN)}[\\s\\S]*?${escapeRegExp(AGENTS_END)}`),
+      AGENTS_BRAIN_BLOCK
+    );
+    if (updated === existing && !options.force) {
+      return { status: "merged" };
+    }
+    (0, import_node_fs6.writeFileSync)(agentsPath, updated, "utf8");
+    return { status: "replaced" };
+  }
+  if (hasBegin !== hasEnd) {
+    if (options.force) {
+      const withoutPartial = existing.replace(new RegExp(`${escapeRegExp(AGENTS_BEGIN)}[\\s\\S]*`), "").replace(AGENTS_END, "");
+      (0, import_node_fs6.writeFileSync)(
+        agentsPath,
+        `${withoutPartial.trimEnd()}
+
+${AGENTS_BRAIN_BLOCK}
+`,
+        "utf8"
+      );
+      return { status: "replaced" };
+    }
+    return writeConflictPatch(cwd, existing);
+  }
+  (0, import_node_fs6.writeFileSync)(agentsPath, `${existing.trimEnd()}
+
+${AGENTS_BRAIN_BLOCK}
+`, "utf8");
+  return { status: "merged" };
+}
+function writeConflictPatch(cwd, existing) {
+  const patchDir = (0, import_node_path6.join)(cwd, ".idia", "patches");
+  (0, import_node_fs6.mkdirSync)(patchDir, { recursive: true });
+  const patchPath = (0, import_node_path6.join)(patchDir, "AGENTS.md.patch");
+  const patchBody = [
+    "# AGENTS.md brain block patch (idia-ui add brain)",
+    "# Apply manually or run: idia-ui add brain --repair --force",
+    "",
+    AGENTS_BRAIN_BLOCK,
+    "",
+    "# --- existing AGENTS.md preserved below ---",
+    "",
+    existing
+  ].join("\n");
+  (0, import_node_fs6.writeFileSync)(patchPath, patchBody, "utf8");
+  return { status: "conflict", patchPath };
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/brain/pack.ts
+var import_node_fs7 = require("fs");
+var import_node_module = require("module");
+var import_node_path7 = require("path");
+function resolveBrainPackRoot(cwd) {
+  const local = (0, import_node_path7.join)(cwd, "node_modules", BRAIN_PACK_NAME);
+  if ((0, import_node_fs7.existsSync)((0, import_node_path7.join)(local, "pack-manifest.json"))) return local;
+  try {
+    const require2 = (0, import_node_module.createRequire)((0, import_node_path7.join)(cwd, "package.json"));
+    const pkgJson = require2.resolve(`${BRAIN_PACK_NAME}/package.json`);
+    return (0, import_node_path7.dirname)(pkgJson);
+  } catch {
+    return null;
+  }
+}
+function readBrainPackManifest(packRoot) {
+  try {
+    const raw = (0, import_node_fs7.readFileSync)((0, import_node_path7.join)(packRoot, "pack-manifest.json"), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function brainPackSpecForApp(cwd) {
+  try {
+    const pkgPath = (0, import_node_path7.join)(cwd, "package.json");
+    const pkg = JSON.parse((0, import_node_fs7.readFileSync)(pkgPath, "utf8"));
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    const usesWorkspace = Object.values(deps).some((v) => v === "workspace:*");
+    if (usesWorkspace) return "workspace:*";
+  } catch {
+  }
+  return "^0.2.0";
+}
+function readInstalledPackManifest(cwd, packageName, manifestFile = "pack-manifest.json") {
+  try {
+    const raw = (0, import_node_fs7.readFileSync)(
+      (0, import_node_path7.join)(cwd, "node_modules", packageName, manifestFile),
+      "utf8"
+    );
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+// src/utils/exec.ts
+var import_node_child_process2 = require("child_process");
+function runPmInstall2(cwd, pm) {
+  const result = spawnCommand(pm, installArgs(pm), cwd);
+  if (result.status !== 0) {
+    throw new Error(`${pm} install failed (exit ${result.status ?? 1})`);
+  }
+}
+function runPmAddDev(cwd, pm, packageSpec) {
+  const result = spawnCommand(pm, addDevArgs(pm, packageSpec), cwd);
+  if (result.status !== 0) {
+    throw new Error(`${pm} add failed for ${packageSpec} (exit ${result.status ?? 1})`);
+  }
+}
+function installArgs(pm) {
+  switch (pm) {
+    case "pnpm":
+      return ["install"];
+    case "yarn":
+      return ["install"];
+    default:
+      return ["install"];
+  }
+}
+function addDevArgs(pm, packageSpec) {
+  switch (pm) {
+    case "pnpm":
+      return ["add", "-D", packageSpec];
+    case "yarn":
+      return ["add", "-D", packageSpec];
+    default:
+      return ["install", "-D", packageSpec];
+  }
+}
+function spawnCommand(pm, args, cwd) {
+  const command = pm === "npm" ? "npm" : pm;
+  return (0, import_node_child_process2.spawnSync)(command, args, { cwd, stdio: "inherit", shell: process.platform === "win32" });
+}
+
+// src/brain/install.ts
+function copyDirRecursive(src, dest, force) {
+  (0, import_node_fs8.mkdirSync)(dest, { recursive: true });
+  for (const entry of (0, import_node_fs8.readdirSync)(src)) {
+    const srcPath = (0, import_node_path8.join)(src, entry);
+    const destPath = (0, import_node_path8.join)(dest, entry);
+    const stat = (0, import_node_fs8.statSync)(srcPath);
+    if (stat.isDirectory()) {
+      copyDirRecursive(srcPath, destPath, force);
+    } else {
+      if (!force && (0, import_node_fs8.existsSync)(destPath)) continue;
+      (0, import_node_fs8.cpSync)(srcPath, destPath);
+    }
+  }
+}
+function ensureBrainPackDependency(cwd, pm, skipInstall) {
+  const pkg = readPackageJson(cwd);
+  if (!pkg) throw new Error("package.json not found");
+  const spec = brainPackSpecForApp(cwd);
+  const existing = pkg.devDependencies?.[BRAIN_PACK_NAME];
+  if (existing === spec || existing === BRAIN_PACK_VERSION) {
+    if (!skipInstall && !(0, import_node_fs8.existsSync)((0, import_node_path8.join)(cwd, "node_modules", BRAIN_PACK_NAME))) {
+      runPmInstall2(cwd, pm);
+    }
+    return;
+  }
+  if (!skipInstall) {
+    runPmAddDev(cwd, pm, `${BRAIN_PACK_NAME}@${spec}`);
+  }
+}
+function isBrainInstalled(cwd, manifest) {
+  const hasAgents = fileExists(cwd, ".idia/brain/AGENTS.md");
+  const hasFeature = Boolean(manifest?.features?.brain?.brainPack);
+  return hasAgents && hasFeature;
+}
+function installBrainPack(options) {
+  const { cwd, repair = false, force = false, skipInstall = false } = options;
+  const pm = options.pm ?? detectPackageManager(cwd);
+  const manifest = readManifest(cwd);
+  if (isBrainInstalled(cwd, manifest) && !repair && !force) {
+    const packRoot2 = resolveBrainPackRoot(cwd);
+    if (packRoot2) {
+      const packManifest2 = readBrainPackManifest(packRoot2);
+      return {
+        alreadyInstalled: true,
+        packRoot: packRoot2,
+        sourceHash: packManifest2?.sourceHash ?? "",
+        agentsPatch: { status: "merged" }
+      };
+    }
+  }
+  ensureBrainPackDependency(cwd, pm, skipInstall);
+  const packRoot = resolveBrainPackRoot(cwd);
+  if (!packRoot) {
+    throw new Error(
+      `${BRAIN_PACK_NAME} not found. Run ${pm} add -D ${BRAIN_PACK_NAME} and retry.`
+    );
+  }
+  const packManifest = readBrainPackManifest(packRoot);
+  if (!packManifest?.sourceHash) {
+    throw new Error(`${BRAIN_PACK_NAME} pack-manifest.json missing or invalid.`);
+  }
+  const brainSrc = (0, import_node_path8.join)(packRoot, "brain");
+  const rulesSrc = (0, import_node_path8.join)(packRoot, "cursor-rules");
+  const brainDest = (0, import_node_path8.join)(cwd, ".idia", "brain");
+  const rulesDest = (0, import_node_path8.join)(cwd, ".cursor", "rules");
+  copyDirRecursive(brainSrc, brainDest, force || repair);
+  (0, import_node_fs8.mkdirSync)(rulesDest, { recursive: true });
+  copyDirRecursive(rulesSrc, rulesDest, force || repair);
+  const agentsPatch = patchRootAgentsMd(cwd, { repair, force });
+  const coreVersion = readInstalledVersion(cwd, "@idia-ui/core") ?? manifest?.core ?? packManifest.core;
+  const nextManifest = {
+    idiaCli: manifest?.idiaCli ?? CLI_VERSION,
+    core: coreVersion,
+    features: {
+      ...manifest?.features,
+      brain: {
+        installed: (/* @__PURE__ */ new Date()).toISOString(),
+        brainPack: packManifest.brainPack,
+        sourceHash: packManifest.sourceHash
+      }
+    }
+  };
+  writeManifest(cwd, nextManifest);
+  return {
+    alreadyInstalled: false,
+    packRoot,
+    sourceHash: packManifest.sourceHash,
+    agentsPatch
+  };
+}
+function printBrainInstallSummary(result) {
+  if (result.alreadyInstalled) {
+    console.log("\u2713 brain pack already installed");
+    console.log(`  .idia/brain/AGENTS.md`);
+    console.log(`  sourceHash: ${result.sourceHash || "(unknown)"}`);
+    console.log("");
+    console.log(BRAIN_TIER_DISCLAIMER);
+    return;
+  }
+  console.log("\u2713 brain pack installed to .idia/brain/");
+  console.log("\u2713 cursor rules copied to .cursor/rules/idia-ui-*.mdc");
+  switch (result.agentsPatch.status) {
+    case "created":
+      console.log("\u2713 AGENTS.md created with idia-ui brain block");
+      break;
+    case "merged":
+      console.log("\u2713 AGENTS.md updated with idia-ui brain block");
+      break;
+    case "replaced":
+      console.log("\u2713 AGENTS.md brain block repaired");
+      break;
+    case "conflict":
+      console.warn(
+        `\u26A0 AGENTS.md conflict \u2014 wrote suggested patch: ${result.agentsPatch.patchPath}`
+      );
+      console.warn("  Run idia-ui add brain --repair --force to overwrite.");
+      break;
+  }
+  console.log(`  sourceHash: ${result.sourceHash}`);
+  console.log("");
+  console.log(BRAIN_TIER_DISCLAIMER);
+}
+
+// src/commands/add.ts
+function runAddBrain(options) {
+  try {
+    const result = installBrainPack({
+      cwd: options.cwd,
+      repair: options.repair,
+      force: options.force,
+      pm: options.pm
+    });
+    printBrainInstallSummary(result);
+    if (result.agentsPatch.status === "conflict") {
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    console.error(BRAIN_TIER_DISCLAIMER);
+    process.exit(1);
+  }
+}
+function runAddUnknown(target) {
+  console.error(`Unknown add target: ${target}`);
+  console.error("Available: storybook, brain");
+  process.exit(1);
+}
+
+// src/checks/packs.ts
+var import_node_fs9 = require("fs");
+var import_node_path9 = require("path");
+function readCoverageManifest(cwd) {
+  try {
+    const raw = (0, import_node_fs9.readFileSync)(
+      (0, import_node_path9.join)(cwd, "node_modules/@idia-ui/storybook-docs/fragments/coverage-manifest.json"),
+      "utf8"
+    );
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function listStoryComponentIds(cwd) {
+  const storiesDir = (0, import_node_path9.join)(cwd, "src/stories");
+  const ids = /* @__PURE__ */ new Set();
+  try {
+    for (const file of (0, import_node_fs9.readdirSync)(storiesDir)) {
+      const match = file.match(/^([A-Za-z]+)\.stories\.(tsx?|jsx?)$/);
+      if (match) {
+        ids.add(match[1].toLowerCase());
+      }
+    }
+  } catch {
+    return [];
+  }
+  return [...ids].sort();
+}
+function runStorybookChecks(cwd) {
+  const hasPreview = fileExists(cwd, ".storybook/preview.tsx");
+  const storybookDocs = fileExists(
+    cwd,
+    "node_modules/@idia-ui/storybook-docs/package.json"
+  );
+  if (!hasPreview && !storybookDocs) {
+    return [
+      {
+        id: "S1",
+        status: "info",
+        message: "Storybook not installed \u2014 skipping S* checks"
+      },
+      {
+        id: "S2",
+        status: "skip",
+        message: "@idia-ui/storybook-docs not installed"
+      },
+      {
+        id: "S3",
+        status: "skip",
+        message: "storybook fragment manifest not available"
+      }
+    ];
+  }
+  const results = [];
+  const preview = readTextFile(cwd, ".storybook/preview.tsx");
+  const importsTamagui = preview !== null && (/tamagui\.config/.test(preview) || /AppProviders/.test(preview));
+  if (importsTamagui) {
+    results.push({
+      id: "S1",
+      status: "pass",
+      message: ".storybook/preview.tsx wires AppProviders (shared token parity)"
+    });
+  } else {
+    results.push({
+      id: "S1",
+      status: "fail",
+      message: ".storybook/preview.tsx missing AppProviders / tamagui.config wiring",
+      fixHint: "idia-ui add storybook --repair"
+    });
+  }
+  const docsVersion = readInstalledVersion(cwd, "@idia-ui/storybook-docs");
+  const coreVersion = readInstalledVersion(cwd, "@idia-ui/core");
+  const docsMinor = docsVersion ? getMinor(docsVersion) : null;
+  const coreMinor = coreVersion ? getMinor(coreVersion) : null;
+  if (!storybookDocs) {
+    results.push({
+      id: "S2",
+      status: "warn",
+      message: "@idia-ui/storybook-docs not installed",
+      fixHint: "idia-ui add storybook"
+    });
+  } else if (docsMinor && coreMinor && docsMinor === coreMinor) {
+    results.push({
+      id: "S2",
+      status: "pass",
+      message: `@idia-ui/storybook-docs@${docsVersion} matches @idia-ui/core@${coreVersion} minor`
+    });
+  } else {
+    results.push({
+      id: "S2",
+      status: "warn",
+      message: `storybook-docs minor (${docsMinor ?? "unknown"}) \u2260 core minor (${coreMinor ?? "unknown"})`,
+      fixHint: "idia-ui sync storybook"
+    });
+  }
+  const coverage = readCoverageManifest(cwd);
+  const coveredIds = coverage?.components ? Object.keys(coverage.components) : [];
+  const storyIds = listStoryComponentIds(cwd);
+  const uncovered = storyIds.filter((id) => !coveredIds.includes(id));
+  if (!coverage) {
+    results.push({
+      id: "S3",
+      status: "warn",
+      message: "coverage manifest not readable",
+      fixHint: "idia-ui sync storybook"
+    });
+  } else if (uncovered.length === 0) {
+    results.push({
+      id: "S3",
+      status: "pass",
+      message: coveredIds.length > 0 ? `fragment manifest covers ${coveredIds.length} Wave 1 components; story files aligned` : "fragment manifest present; no src/stories/ files to cross-ref"
+    });
+    if (coveredIds.length > 0 && coveredIds.length < 10) {
+      results.push({
+        id: "S3-info",
+        status: "info",
+        message: `storybook-docs pack has doc fragments for ${coveredIds.length} components. Other components render without brain prose.`
+      });
+    }
+  } else {
+    results.push({
+      id: "S3",
+      status: "warn",
+      message: `stories without fragments: ${uncovered.join(", ")}`,
+      fixHint: "upgrade @idia-ui/storybook-docs or remove uncovered stories"
+    });
+  }
+  const manifest = readManifest(cwd);
+  if (storybookDocs && !manifest?.features?.storybook) {
+    results.push({
+      id: "S-manifest",
+      status: "warn",
+      message: "manifest features.storybook missing",
+      fixHint: "idia-ui sync storybook"
+    });
+  }
+  return results;
+}
+function readPackSourceHash(cwd, packageName) {
+  return readInstalledPackManifest(cwd, packageName)?.sourceHash ?? null;
+}
+function runBrainChecks(cwd) {
+  const brainPackInstalled = fileExists(
+    cwd,
+    "node_modules/@idia-ui/brain-pack/package.json"
+  );
+  const brainAgents = fileExists(cwd, ".idia/brain/AGENTS.md");
+  const rootAgents = readTextFile(cwd, "AGENTS.md");
+  const hasBrainBlock = rootAgents !== null && /idia-ui brain:begin/.test(rootAgents) && /idia-ui brain:end/.test(rootAgents);
+  if (!brainPackInstalled && !brainAgents) {
+    return [
+      {
+        id: "B1",
+        status: "warn",
+        message: "brain pack not installed",
+        fixHint: "Run idia-ui add brain"
+      },
+      {
+        id: "B2",
+        status: "skip",
+        message: "AGENTS.md brain block not present"
+      },
+      {
+        id: "B3",
+        status: "skip",
+        message: "brain sourceHash coupling not checked"
+      },
+      {
+        id: "B4",
+        status: "skip",
+        message: "brain/storybook hash coupling not checked"
+      }
+    ];
+  }
+  const results = [];
+  const manifest = readManifest(cwd);
+  const manifestHash = manifest?.features?.brain?.sourceHash;
+  const packRoot = resolveBrainPackRoot(cwd);
+  const packManifest = packRoot ? readBrainPackManifest(packRoot) : null;
+  const packHash = packManifest?.sourceHash;
+  results.push({
+    id: "B1",
+    status: brainAgents ? "pass" : "warn",
+    message: brainAgents ? "\u2713 brain pack installed" : ".idia/brain/AGENTS.md missing",
+    fixHint: brainAgents ? void 0 : "idia-ui add brain"
+  });
+  results.push({
+    id: "B2",
+    status: hasBrainBlock ? "pass" : "warn",
+    message: hasBrainBlock ? "root AGENTS.md contains idia-ui brain block" : "root AGENTS.md missing idia-ui brain:begin/end block",
+    fixHint: hasBrainBlock ? void 0 : "idia-ui add brain --repair"
+  });
+  if (manifestHash && packHash && manifestHash === packHash) {
+    results.push({
+      id: "B3",
+      status: "pass",
+      message: "manifest sourceHash matches installed brain pack"
+    });
+  } else if (manifestHash && packHash) {
+    results.push({
+      id: "B3",
+      status: "warn",
+      message: "manifest sourceHash drifted from brain pack pin",
+      fixHint: "idia-ui sync brain"
+    });
+  } else {
+    results.push({
+      id: "B3",
+      status: "warn",
+      message: "manifest sourceHash missing or brain pack not resolved",
+      fixHint: "idia-ui sync brain"
+    });
+  }
+  const storybookHash = readPackSourceHash(cwd, "@idia-ui/storybook-docs");
+  if (!storybookHash) {
+    results.push({
+      id: "B4",
+      status: "skip",
+      message: "storybook-docs not installed \u2014 B4 hash coupling skipped"
+    });
+  } else if (packHash && storybookHash === packHash) {
+    results.push({
+      id: "B4",
+      status: "pass",
+      message: "brain pack and storybook-docs share sourceHash (same generate run)"
+    });
+  } else {
+    results.push({
+      id: "B4",
+      status: "warn",
+      message: "brain pack and storybook-docs sourceHash skew",
+      fixHint: "idia-ui sync all"
+    });
+  }
+  results.push({
+    id: "B-tier",
+    status: "info",
+    message: `\u26A0 ${BRAIN_DOCTOR_DISCLAIMER}`
+  });
+  return results;
+}
+function runCustomCheck(cwd) {
+  const hasStories = fileExists(cwd, "src/stories");
+  if (!hasStories) {
+    return [
+      {
+        id: "C1",
+        status: "skip",
+        message: "no src/stories/ directory (Storybook not configured)"
+      }
+    ];
+  }
+  return [
+    {
+      id: "C1",
+      status: "info",
+      message: "wrapper/story coverage check not implemented (stub)",
+      fixHint: "Add stories for components in src/components/"
+    }
+  ];
+}
+
+// src/checks/manifest.ts
+function runManifestCheck(cwd, fix) {
+  const results = [];
+  let fixed = false;
+  if (!manifestExists(cwd)) {
+    if (fix) {
+      const pkg = readPackageJson(cwd);
+      const coreVersion = readInstalledVersion(cwd, "@idia-ui/core") ?? pkg?.dependencies?.["@idia-ui/core"]?.replace(/^[\^~]/, "") ?? "0.2.0";
+      regenerateManifest(cwd, coreVersion);
+      fixed = true;
+      results.push({
+        id: "M1",
+        status: "pass",
+        message: ".idia/manifest.json regenerated",
+        fixHint: "Created manifest with idiaCli + core versions"
+      });
+      return { results, fixed };
+    }
+    results.push({
+      id: "M1",
+      status: "warn",
+      message: ".idia/manifest.json missing",
+      fixHint: "Run idia-ui doctor --fix or idia-ui sync all after first add-on"
+    });
+    return { results, fixed };
+  }
+  const manifest = readManifest(cwd);
+  if (!manifest || !validateManifestShape(manifest)) {
+    results.push({
+      id: "M1",
+      status: "fail",
+      message: ".idia/manifest.json invalid or unparseable",
+      fixHint: "Run idia-ui doctor --fix to regenerate"
+    });
+    return { results, fixed };
+  }
+  results.push({
+    id: "M1",
+    status: "pass",
+    message: `.idia/manifest.json valid (core ${manifest.core}, cli ${manifest.idiaCli})`
+  });
+  return { results, fixed };
+}
+
+// src/checks/navigation.ts
+function runNavigationChecks(cwd) {
+  const results = [];
+  const providers = readTextFile(cwd, "src/providers/AppProviders.tsx") ?? readTextFile(cwd, "src/providers/AppProviders.ts");
+  if (providers && /NavigationContainer/.test(providers)) {
+    results.push({
+      id: "N1",
+      status: "pass",
+      message: "NavigationContainer in provider tree"
+    });
+  } else {
+    results.push({
+      id: "N1",
+      status: "fail",
+      message: "NavigationContainer not found in AppProviders",
+      fixHint: "Wrap navigation in NavigationContainer per templates/consumer-app"
+    });
+  }
+  const usesIdiaNav = grepSrcForPattern(cwd, /\bLink\b.*@idia-ui\/core/) || grepSrcForPattern(cwd, /NavigationProvider/) || grepSrcForPattern(cwd, /useIdiaNavigation|navigateTo/);
+  if (usesIdiaNav) {
+    const hasNavProvider = providers ? /NavigationProvider/.test(providers) : grepSrcForPattern(cwd, /NavigationProvider/);
+    if (!hasNavProvider) {
+      results.push({
+        id: "N2",
+        status: "warn",
+        message: "idia Link/navigation helpers used but NavigationProvider missing",
+        fixHint: "Wrap navigation ref with NavigationProvider from @idia-ui/core"
+      });
+    } else {
+      results.push({
+        id: "N2",
+        status: "pass",
+        message: "NavigationProvider present"
+      });
+    }
+  } else {
+    results.push({
+      id: "N2",
+      status: "pass",
+      message: "idia Link/navigation helpers not used (NavigationProvider optional)"
+    });
+  }
+  return results;
+}
+
+// src/checks/peers.ts
+var P2_PACKAGES = [
+  "react-native-reanimated",
+  "react-native-gesture-handler",
+  "react-native-screens",
+  "react-native-safe-area-context"
+];
+var BARREL_REQUIRED_PEERS = ["zustand", "@tanstack/react-table"];
+var BARREL_OPTIONAL_PEERS = [
+  "react-image-crop",
+  "@fullcalendar/core",
+  "@fullcalendar/daygrid",
+  "@fullcalendar/timegrid",
+  "@fullcalendar/interaction",
+  "@fullcalendar/multimonth",
+  "@fullcalendar/list",
+  "@fullcalendar/react"
+];
+function runPeerChecks(cwd) {
+  const pkg = readPackageJson(cwd);
+  if (!pkg) {
+    return [
+      {
+        id: "P0",
+        status: "fail",
+        message: "package.json not found or unreadable",
+        fixHint: "Run idia-ui doctor from your app root"
+      }
+    ];
+  }
+  const pm = detectPackageManager(cwd);
+  const results = [];
+  const tamaguiVersion = readInstalledVersion(cwd, "tamagui") ?? getDepVersion(pkg, "tamagui")?.replace(/^[\^~]/, "") ?? null;
+  const coreRange = readPeerRange(cwd, "@idia-ui/core", "tamagui") ?? readPeerRange(cwd, "@idia-ui/theme", "tamagui") ?? "^1.70.0";
+  if (!tamaguiVersion) {
+    results.push({
+      id: "P1",
+      status: "fail",
+      message: "tamagui not installed",
+      fixHint: pmAddCommand(pm, ["tamagui@^1.144.0"])
+    });
+  } else if (!satisfiesRange(tamaguiVersion, coreRange)) {
+    results.push({
+      id: "P1",
+      status: "fail",
+      message: `tamagui ${tamaguiVersion} outside peer range ${coreRange}`,
+      fixHint: pmAddCommand(pm, [`tamagui@${coreRange}`])
+    });
+  } else {
+    results.push({
+      id: "P1",
+      status: "pass",
+      message: `tamagui ${tamaguiVersion} in peer range`
+    });
+  }
+  const missingP2 = P2_PACKAGES.filter((name) => {
+    const installed = readInstalledVersion(cwd, name);
+    const declared = getDepVersion(pkg, name);
+    return !installed && !declared;
+  });
+  if (missingP2.length > 0) {
+    results.push({
+      id: "P2",
+      status: "fail",
+      message: `missing navigation/gesture peers: ${missingP2.join(", ")}`,
+      fixHint: pmAddCommand(pm, [...missingP2])
+    });
+  } else {
+    results.push({
+      id: "P2",
+      status: "pass",
+      message: "gesture-handler, reanimated, screens, safe-area-context present"
+    });
+  }
+  const idiaPkgs = Object.keys({
+    ...pkg.dependencies,
+    ...pkg.devDependencies
+  }).filter((n) => n.startsWith("@idia-ui/"));
+  const idiaVersions = idiaPkgs.map((name) => {
+    const v = readInstalledVersion(cwd, name) ?? getDepVersion(pkg, name)?.replace(/^[\^~]/, "");
+    return v ? { name, version: v } : null;
+  }).filter((x) => x !== null);
+  const minors = new Set(
+    idiaVersions.map((p) => {
+      const parts = p.version.split(".");
+      return parts.length >= 2 ? `${parts[0]}.${parts[1]}` : null;
+    }).filter((m) => m !== null && !m.includes("workspace"))
+  );
+  if (idiaVersions.length === 0) {
+    results.push({
+      id: "P3",
+      status: "fail",
+      message: "no @idia-ui/* packages in dependencies",
+      fixHint: pmAddCommand(pm, ["@idia-ui/core@latest", "@idia-ui/theme@latest"])
+    });
+  } else if (minors.size > 1) {
+    results.push({
+      id: "P3",
+      status: "fail",
+      message: `@idia-ui/* minor versions misaligned: ${[...minors].join(", ")}`,
+      fixHint: `${pm === "pnpm" ? "pnpm" : pm} update @idia-ui/*`
+    });
+  } else {
+    results.push({
+      id: "P3",
+      status: "pass",
+      message: `@idia-ui/* versions aligned (${idiaVersions.map((p) => `${p.name}@${p.version}`).join(", ")})`
+    });
+  }
+  for (const peer of BARREL_REQUIRED_PEERS) {
+    const installed = readInstalledVersion(cwd, peer);
+    const declared = getDepVersion(pkg, peer);
+    if (!installed && !declared) {
+      results.push({
+        id: "P3",
+        status: "fail",
+        message: `barrel peer ${peer} not installed (required for @idia-ui/core Table graph)`,
+        fixHint: `${pmAddCommand(pm, [peer])} \u2014 see docs/generated/peer-dep-matrix.md`
+      });
+    }
+  }
+  for (const peer of BARREL_OPTIONAL_PEERS) {
+    const installed = readInstalledVersion(cwd, peer);
+    const declared = getDepVersion(pkg, peer);
+    if (!installed && !declared) {
+      results.push({
+        id: "P3",
+        status: "warn",
+        message: `optional peer ${peer} not installed (barrel may require it)`,
+        fixHint: `Install per peer-dep-matrix.md: ${pmAddCommand(pm, [peer])}`
+      });
+    }
+  }
+  return results;
+}
+
+// src/checks/runtime.ts
+var OVERLAY_IMPORT = /from\s+['"]@idia-ui\/core['"][\s\S]*?(Modal|Toast|Dialog|ConfirmationModal)/;
+function runRuntimeChecks(cwd) {
+  const results = [];
+  if (fileExists(cwd, "tamagui.config.ts")) {
+    results.push({
+      id: "R1",
+      status: "pass",
+      message: "tamagui.config.ts found"
+    });
+  } else {
+    results.push({
+      id: "R1",
+      status: "fail",
+      message: "tamagui.config.ts missing at app root",
+      fixHint: "Restore from templates/consumer-app or re-scaffold"
+    });
+  }
+  const providers = readTextFile(cwd, "src/providers/AppProviders.tsx") ?? readTextFile(cwd, "src/providers/AppProviders.ts");
+  if (!providers) {
+    results.push({
+      id: "R2",
+      status: "fail",
+      message: "AppProviders not found",
+      fixHint: "Add src/providers/AppProviders.tsx per templates/consumer-app"
+    });
+  } else {
+    const hasTamagui = /TamaguiProvider/.test(providers);
+    const hasTheme = /ThemeProvider/.test(providers) && /@idia-ui\/theme/.test(providers);
+    if (hasTamagui && hasTheme) {
+      results.push({
+        id: "R2",
+        status: "pass",
+        message: "AppProviders: TamaguiProvider + ThemeProvider"
+      });
+    } else {
+      results.push({
+        id: "R2",
+        status: "fail",
+        message: "AppProviders missing TamaguiProvider and/or ThemeProvider (@idia-ui/theme)",
+        fixHint: "Compare src/providers/AppProviders.tsx with templates/consumer-app"
+      });
+    }
+  }
+  const usesOverlays = grepSrcForPattern(cwd, OVERLAY_IMPORT) || grepSrcForPattern(cwd, /\b(Modal|Toast|Dialog)\b.*@idia-ui\/core/);
+  if (usesOverlays) {
+    const hasModal = providers ? /ModalProvider/.test(providers) : false;
+    const hasToast = providers ? /ToastProvider/.test(providers) : false;
+    if (!hasModal || !hasToast) {
+      results.push({
+        id: "R3",
+        status: "warn",
+        message: "overlay components imported but ModalProvider/ToastProvider missing",
+        fixHint: "Add ModalProvider and ToastProvider to AppProviders per template"
+      });
+    } else {
+      results.push({
+        id: "R3",
+        status: "pass",
+        message: "overlay providers present"
+      });
+    }
+  } else {
+    results.push({
+      id: "R3",
+      status: "pass",
+      message: "no overlay imports detected (Modal/Toast providers optional)"
+    });
+  }
+  const fontGate = providers && /waitForWebFonts/.test(providers) || grepSrcForPattern(cwd, /expo-font/) || grepSrcForPattern(cwd, /useFonts/);
+  if (fontGate) {
+    results.push({
+      id: "R4",
+      status: "pass",
+      message: "web font gate configured (waitForWebFonts or expo-font)"
+    });
+  } else {
+    results.push({
+      id: "R4",
+      status: "warn",
+      message: "no waitForWebFonts or expo-font pattern detected",
+      fixHint: "Copy font loading pattern from templates/consumer-app AppProviders"
+    });
+  }
+  return results;
+}
+
+// src/checks/index.ts
+function runAllChecks(options) {
+  const { cwd, full, fix } = options;
+  const checks = [];
+  checks.push(...runPeerChecks(cwd));
+  checks.push(...runRuntimeChecks(cwd));
+  checks.push(...runNavigationChecks(cwd));
+  const { results: manifestResults } = runManifestCheck(cwd, fix);
+  checks.push(...manifestResults);
+  if (full) {
+    checks.push(...runStorybookChecks(cwd));
+    checks.push(...runBrainChecks(cwd));
+    checks.push(...runCustomCheck(cwd));
+  }
+  return checks;
+}
+function summarizeChecks(checks, strict) {
+  let passed = 0;
+  let warnings = 0;
+  let failures = 0;
+  let skipped = 0;
+  for (const check of checks) {
+    switch (check.status) {
+      case "pass":
+        passed++;
+        break;
+      case "warn":
+        warnings++;
+        break;
+      case "fail":
+        failures++;
+        break;
+      case "skip":
+      case "info":
+        skipped++;
+        break;
+    }
+  }
+  let exitCode = 0;
+  if (failures > 0) exitCode = 1;
+  else if (strict && warnings > 0) exitCode = 1;
+  return { passed, warnings, failures, skipped, exitCode };
+}
+
+// src/commands/doctor.ts
+var STATUS_ICON = {
+  pass: "\u2713",
+  warn: "\u26A0",
+  fail: "\u2717",
+  info: "\u2139",
+  skip: "\u25CB"
+};
+function runDoctor(options) {
+  const checks = runAllChecks(options);
+  const summary = summarizeChecks(checks, options.strict);
+  return {
+    checks,
+    summary: {
+      passed: summary.passed,
+      warnings: summary.warnings,
+      failures: summary.failures,
+      skipped: summary.skipped
+    },
+    exitCode: summary.exitCode
+  };
+}
+function formatHumanReport(report, full) {
+  const lines = ["idia-ui doctor", ""];
+  for (const check of report.checks) {
+    const icon = STATUS_ICON[check.status] ?? "\xB7";
+    lines.push(`${icon} ${check.id}  ${check.message}`);
+    if (check.fixHint && (check.status === "fail" || check.status === "warn")) {
+      lines.push(`    \u2192 ${check.fixHint}`);
+    }
+  }
+  lines.push("");
+  const { passed, warnings, failures } = report.summary;
+  const mode = full ? "full" : "quick";
+  lines.push(
+    `${passed} passed, ${warnings} warnings, ${failures} failures (${mode} scan) \u2014 exit ${report.exitCode}`
+  );
+  return lines.join("\n");
+}
+function formatJsonReport(report) {
+  return JSON.stringify(
+    {
+      checks: report.checks.map((c) => ({
+        id: c.id,
+        status: c.status,
+        message: c.message,
+        ...c.fixHint ? { fixHint: c.fixHint } : {}
+      })),
+      summary: report.summary,
+      exitCode: report.exitCode
+    },
+    null,
+    2
+  );
+}
+
+// src/commands/storybook/sync.ts
+var import_node_child_process3 = require("child_process");
+function isStorybookInstalled2(cwd) {
+  return fileExists(cwd, ".storybook/main.ts");
+}
+function runPmUpdate(cwd, pm) {
+  const packages = [
+    `@idia-ui/storybook-docs@${STORYBOOK_DOCS_VERSION}`,
+    `@idia-ui/storybook-preset-react-native-web@${STORYBOOK_PRESET_VERSION}`
+  ];
+  const args = pm === "pnpm" ? ["add", "-D", ...packages] : pm === "yarn" ? ["add", "-D", ...packages] : ["install", "-D", ...packages];
+  const result = (0, import_node_child_process3.spawnSync)(pm, args, {
+    cwd,
+    stdio: "inherit",
+    shell: process.platform === "win32"
+  });
+  if (result.status !== 0) {
+    throw new Error(`${pm} update failed with exit code ${result.status ?? "unknown"}`);
+  }
+}
+function runSyncStorybook(options) {
+  const { cwd, skipInstall = false } = options;
+  const pm = options.pm ?? detectPackageManager(cwd);
+  if (!isStorybookInstalled2(cwd)) {
+    console.error("Storybook not installed \u2014 run idia-ui add storybook first");
+    process.exit(1);
+  }
+  const manifest = readManifest(cwd);
+  if (!manifest) {
+    console.error(".idia/manifest.json missing \u2014 run idia-ui doctor --fix");
+    process.exit(1);
+  }
+  const corePkg = readPackageJson(cwd);
+  const coreVersion = readInstalledVersion(cwd, "@idia-ui/core") ?? corePkg?.dependencies?.["@idia-ui/core"]?.replace(/^[\^~]/, "") ?? manifest.core;
+  if (!skipInstall) {
+    console.log(`Syncing storybook packs via ${pm}\u2026`);
+    runPmUpdate(cwd, pm);
+  }
+  manifest.idiaCli = CLI_VERSION;
+  manifest.core = coreVersion;
+  manifest.features ??= {};
+  manifest.features.storybook = {
+    installed: manifest.features.storybook?.installed ?? (/* @__PURE__ */ new Date()).toISOString(),
+    storybookDocs: STORYBOOK_DOCS_VERSION,
+    storybook: STORYBOOK_CLI_VERSION,
+    preset: STORYBOOK_PRESET_VERSION
+  };
+  writeManifest(cwd, manifest);
+  console.log(`\u2713 Synced @idia-ui/storybook-docs@${STORYBOOK_DOCS_VERSION}`);
+  console.log(`\u2713 Synced @idia-ui/storybook-preset-react-native-web@${STORYBOOK_PRESET_VERSION}`);
+  return {
+    synced: true,
+    message: `storybook-docs@${STORYBOOK_DOCS_VERSION} aligned with core@${coreVersion}`
+  };
+}
+
+// src/commands/sync.ts
+function runSyncBrain(options) {
+  try {
+    const result = installBrainPack({
+      cwd: options.cwd,
+      repair: true,
+      force: options.force,
+      pm: options.pm
+    });
+    console.log("\u2713 brain pack synced");
+    printBrainInstallSummary(result);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    console.error(BRAIN_TIER_DISCLAIMER);
+    process.exit(1);
+  }
+}
+function runSyncStorybook2(options) {
+  runSyncStorybook({
+    cwd: options.cwd,
+    pm: options.pm
+  });
+}
+function runSyncAll(options) {
+  const { cwd } = options;
+  const manifest = readManifest(cwd);
+  const hasStorybook = fileExists(cwd, ".storybook/main.ts") || Boolean(manifest?.features?.storybook);
+  const hasBrain = Boolean(manifest?.features?.brain?.brainPack);
+  if (!hasStorybook && !hasBrain) {
+    console.error("No storybook or brain features installed \u2014 run idia-ui add storybook or add brain first");
+    process.exit(1);
+  }
+  if (hasStorybook) {
+    runSyncStorybook({ cwd, pm: options.pm });
+  } else {
+    console.log("\u25CB storybook not installed \u2014 skipping storybook sync");
+  }
+  if (hasBrain) {
+    runSyncBrain(options);
+  } else {
+    console.log("\u25CB brain not installed \u2014 skipping brain sync");
+    console.error(BRAIN_DOCTOR_DISCLAIMER);
+  }
+  console.log("");
+  console.log("\u2713 sync all complete");
+}
+function runSync(target, options) {
+  switch (target) {
+    case "brain":
+      runSyncBrain(options);
+      break;
+    case "storybook":
+      runSyncStorybook2(options);
+      break;
+    case "all":
+      runSyncAll(options);
+      break;
+    default:
+      console.error(`Unknown sync target: ${target}`);
+      console.error("Available: storybook | brain | all");
+      process.exit(1);
+  }
+}
+
+// src/cli.ts
+var program = new import_commander.Command();
+program.name("idia-ui").description("idia-ui CLI \u2014 doctor and add-on management for consumer apps").version(CLI_VERSION);
+program.command("doctor").description("Run health checks on an idia consumer app").option("--cwd <path>", "App root directory", process.cwd()).option("--full", "Include Storybook (S*) and brain (B*) checks").option("--fix", "Limited safe repairs (manifest regenerate)").option("--strict", "Treat warnings as failures").option("--json", "Machine-readable JSON output").action((opts) => {
+  const cwd = (0, import_node_path10.resolve)(opts.cwd);
+  const report = runDoctor({
+    cwd,
+    full: Boolean(opts.full),
+    fix: Boolean(opts.fix),
+    strict: Boolean(opts.strict),
+    json: Boolean(opts.json)
+  });
+  if (opts.json) {
+    console.log(formatJsonReport(report));
+  } else {
+    console.log(formatHumanReport(report, Boolean(opts.full)));
+  }
+  process.exit(report.exitCode);
+});
+var addCmd = program.command("add").description("Install idia add-on packs");
+addCmd.command("storybook").description("Install Storybook docs pack").option("--repair", "Refresh CLI-owned Storybook files").option("--force", "Overwrite conflicts (document risk)").option("--skip-install", "Skip package manager install").option("--pm <manager>", "Override package manager (pnpm|npm|yarn)").option("--cwd <path>", "App root directory", process.cwd()).action(
+  (opts) => {
+    runAddStorybook({
+      cwd: (0, import_node_path10.resolve)(opts.cwd),
+      repair: Boolean(opts.repair),
+      force: Boolean(opts.force),
+      skipInstall: Boolean(opts.skipInstall),
+      pm: parsePm(opts.pm)
+    });
+  }
+);
+addCmd.command("brain").description("Install brain AI pack (Phase 4 \u2014 experimental)").option("--repair", "Re-apply rules, AGENTS block, and .idia/brain/ from pack").option("--force", "Overwrite conflicts (document risk)").option("--pm <manager>", "Override package manager (pnpm|npm|yarn)").option("--cwd <path>", "App root directory", process.cwd()).action((opts) => {
+  runAddBrain({
+    cwd: (0, import_node_path10.resolve)(opts.cwd),
+    repair: Boolean(opts.repair),
+    force: Boolean(opts.force),
+    pm: parsePm(opts.pm)
+  });
+});
+addCmd.argument("[target]", "add-on target").action((target) => {
+  if (!target) {
+    console.error("Usage: idia-ui add <storybook|brain>");
+    process.exit(1);
+  }
+  runAddUnknown(target);
+});
+var syncCmd = program.command("sync").description("Sync installed pack versions and manifest");
+syncCmd.argument("<target>", "storybook | brain | all").option("--force", "Overwrite pack-owned files").option("--pm <manager>", "Override package manager (pnpm|npm|yarn)").option("--cwd <path>", "App root directory", process.cwd()).action((target, opts) => {
+  runSync(target, {
+    cwd: (0, import_node_path10.resolve)(opts.cwd),
+    force: Boolean(opts.force),
+    pm: parsePm(opts.pm)
+  });
+});
+program.parse();
+function parsePm(value) {
+  if (!value) return void 0;
+  const normalized = value.toLowerCase();
+  if (normalized === "pnpm" || normalized === "npm" || normalized === "yarn") {
+    return normalized;
+  }
+  console.error(`Invalid --pm value "${value}". Use pnpm, npm, or yarn.`);
+  process.exit(1);
+}
+//# sourceMappingURL=cli.js.map