vybekiit 0.1.0

package/LICENSE.md

@@ -0,0 +1,47 @@
+# VybeKiit licensing
+
+This repository is **dual-licensed by component**, matching the Owned vs Maintained split (see
+`CONTEXT.md`). Which license applies depends only on the path:
+
+| Path | License | Why |
+|---|---|---|
+| `packages/*` (published `@vybekiit/*`) | **MIT** | Public, headless logic — free updates double as marketing; nothing secret here. |
+| `cli/` (the published `vybekiit` scaffolder) | **MIT** | The public npm CLI anyone may `npx`; the paid gate is repo access, not the CLI itself. |
+| `templates/*` + the buyer agent layer (`.vybekiit/`, and each template's `AGENTS.md` / `CLAUDE.md` / `.cursor/rules` / `language.md` / `BUILDER-VOICE.md`) | **Proprietary — VybeKiit EULA** | The paid, owned product. Full terms in [`EULA.md`](./EULA.md). |
+| `apps/landing/`, root tooling/config, and other repo internals | Proprietary (not distributed) | Our store and build infrastructure — never shipped to a buyer. |
+
+The MIT-licensed paths are the only parts published to public npm. The proprietary paths reach
+buyers through private GitHub mirror repos after purchase (the gate) and are governed by the
+[VybeKiit EULA](./EULA.md), which includes a plain-language summary of what a buyer can and can't do.
+
+---
+
+## MIT License — applies to `packages/*` and `cli/`
+
+Copyright (c) 2026 VybeKiit authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---
+
+## Proprietary — applies to `templates/*` and the buyer agent layer
+
+These paths are **not** open source. They are the paid product, licensed (not sold) to buyers under
+the **[VybeKiit EULA](./EULA.md)**. In short: a buyer may build unlimited products of their own,
+including commercial ones, but may **not** redistribute, resell, or republish the kit itself, build a
+competing kit with it, or share their access. Provided as-is, no warranty, liability capped at the
+amount paid, best-effort updates with no compatibility guarantee. See `EULA.md` for the full terms
+and the plain-language buyer summary.

package/README.md

@@ -0,0 +1,84 @@
+# vybekiit
+
+Scaffold a VybeKiit template into your own repo, then build it by describing what you
+want to your AI coding agent (Claude Code, Codex, or Cursor) — it does the heavy lift.
+
+## Get started
+
+```sh
+npx vybekiit new web my-app
+```
+
+This creates `my-app/` from the `web` template. Open the folder in your AI coding tool
+and tell it `"Set up my app."` — the agent reads its instructions and walks you through
+the rest one step at a time.
+
+Before your first build, install and check the tools your app needs:
+
+```sh
+vybekiit doctor
+```
+
+`doctor` installs and checks your full toolchain and reports what's ready:
+
+| Layer | Tools |
+| ----- | ----- |
+| Agent | `claude` (Claude Code), `codex` (OpenAI Codex), `skills` (platform skills installer) |
+| Base | `gh` (download templates + GitHub login) |
+| Default cloud | `supabase` (database), `wrangler` (hosting) |
+| When configured | `aws`, `gcloud` (Google sign-in), `vercel`, `eas` + `launch` (mobile) |
+
+Doctor reads your `.env` provider settings and only installs what you use. It also verifies
+official platform skills are present under `.agents/skills/`. When you enable Google sign-in,
+doctor installs and checks `gcloud` auth.
+
+## Commands
+
+```
+vybekiit new <template> [directory]   Scaffold a template into your own repo
+vybekiit doctor                       Set up + check the tools your app needs
+vybekiit sync-agent-layer [template]  Refresh agent instructions from the latest mirror
+
+  -h, --help       Show help
+  -v, --version    Show the CLI version
+```
+
+Examples:
+
+```sh
+vybekiit new web my-app
+vybekiit new web .
+vybekiit doctor
+```
+
+### Templates
+
+| Template    | Stack                                  | Status         |
+| ----------- | -------------------------------------- | -------------- |
+| `web`       | Next.js + shadcn (RTL-ready) + agent layer | available  |
+| `mobile`    | Expo + agent layer                     | available      |
+| `extension` | WXT + agent layer                      | ships in v3    |
+
+Every template ships the **agent layer** — the instructions and skills your AI agent
+follows to set up, build, and ship your app.
+
+## How delivery works
+
+Templates are proprietary and live in private per-template mirror repos; the published
+npm package ships **no** template files. When you run `vybekiit new`, the CLI clones the
+template you've purchased access to using GitHub's `gh` CLI — one browser login, no
+tokens to create or paste. The copied project starts as a fresh repo (the mirror's git
+history is not carried over), and any `@vybekiit/*` workspace dependencies are rewritten
+to pinned npm versions so it builds on its own.
+
+If you haven't signed in yet, the CLI tells you exactly what to run:
+`gh auth login --web`. `doctor` installs `gh` for you.
+
+## Requirements
+
+- **Node.js 20+** (the project toolchain targets Node 22).
+- Everything else — agent CLIs, `gh`, `supabase`, `wrangler`, `gcloud`, `aws` — is installed by `vybekiit doctor`.
+
+## License
+
+MIT.

package/dist/index.js

@@ -0,0 +1,953 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { readFile as readFile3 } from "fs/promises";
+import { dirname as dirname2, join as join9, resolve as resolve2 } from "path";
+import process4 from "process";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/doctor/run.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { existsSync as existsSync4, readFileSync as readFileSync5 } from "fs";
+import { join as join5 } from "path";
+import process from "process";
+import { inferVybeAssistant } from "@vybekiit/report-mode";
+
+// src/doctor/env.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+function loadEnvFile(cwd) {
+  const path = join(cwd, ".env");
+  if (!existsSync(path)) {
+    return {};
+  }
+  const out = {};
+  const raw = readFileSync(path, "utf8");
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const eq = trimmed.indexOf("=");
+    if (eq <= 0) {
+      continue;
+    }
+    const key = trimmed.slice(0, eq).trim();
+    let value = trimmed.slice(eq + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    out[key] = value;
+  }
+  return out;
+}
+function mergeEnv(processEnv, fileEnv) {
+  return { ...processEnv, ...fileEnv };
+}
+function writeEnvKeys(cwd, keys) {
+  const path = join(cwd, ".env");
+  const existing = existsSync(path) ? readFileSync(path, "utf8") : "";
+  const lines = existing.length > 0 ? existing.split("\n") : [];
+  const written = /* @__PURE__ */ new Set();
+  for (const [key, value] of Object.entries(keys)) {
+    const quoted = value.includes(" ") ? `"${value}"` : value;
+    const newLine = `${key}=${quoted}`;
+    let replaced = false;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line === void 0) {
+        continue;
+      }
+      const trimmed = line.trim();
+      if (trimmed.startsWith(`${key}=`)) {
+        lines[i] = newLine;
+        replaced = true;
+        written.add(key);
+        break;
+      }
+    }
+    if (!replaced) {
+      lines.push(newLine);
+      written.add(key);
+    }
+  }
+  const output = lines.join("\n").replace(/\n*$/, "\n");
+  writeFileSync(
+    path,
+    output.length > 0 ? output : `${Object.entries(keys).map(([k, v]) => `${k}=${v}`).join("\n")}
+`
+  );
+}
+
+// src/doctor/platform-skills.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+function detectTemplate(cwd) {
+  if (existsSync2(join2(cwd, "platform-skills.manifest.json"))) {
+    if (existsSync2(join2(cwd, "app.json"))) return "mobile";
+    if (existsSync2(join2(cwd, "wxt.config.ts")) || existsSync2(join2(cwd, "extension.config.ts"))) {
+      return "extension";
+    }
+    return "web";
+  }
+  return null;
+}
+function readManifest(cwd) {
+  const path = join2(cwd, "platform-skills.manifest.json");
+  if (!existsSync2(path)) {
+    return null;
+  }
+  return JSON.parse(readFileSync2(path, "utf8"));
+}
+function expectedSkillNames(manifest) {
+  const names = /* @__PURE__ */ new Set();
+  for (const source of manifest.sources) {
+    for (const skill of source.skills) {
+      if (skill === "*") {
+        continue;
+      }
+      names.add(skill);
+    }
+  }
+  return [...names];
+}
+function verifyPlatformSkills(cwd) {
+  const manifest = readManifest(cwd);
+  if (!manifest) {
+    return { ok: true, missing: [], template: null };
+  }
+  const missing = [];
+  for (const name of expectedSkillNames(manifest)) {
+    const skillPath = join2(cwd, ".agents", "skills", name, "SKILL.md");
+    if (!existsSync2(skillPath)) {
+      missing.push(name);
+    }
+  }
+  return {
+    ok: missing.length === 0,
+    missing,
+    template: detectTemplate(cwd)
+  };
+}
+function formatPlatformSkillsReport(report) {
+  if (report.template === null) {
+    return [];
+  }
+  if (report.ok) {
+    return ["\u2713 platform skills \u2014 all official skills are present."];
+  }
+  return [
+    `\u2192 platform skills \u2014 missing: ${report.missing.join(", ")}. Ask your agent to refresh platform skills (update-kit) or run the pin script.`
+  ];
+}
+
+// src/doctor/project-health.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
+function gitignoreCoversEnv(cwd) {
+  const path = join3(cwd, ".gitignore");
+  if (!existsSync3(path)) {
+    return false;
+  }
+  const content = readFileSync3(path, "utf8");
+  return /^\.env/m.test(content) || content.includes(".env\n") || content.includes(".env\r\n");
+}
+function cursorignoreCoversEnv(cwd) {
+  const path = join3(cwd, ".cursorignore");
+  if (!existsSync3(path)) {
+    return false;
+  }
+  const content = readFileSync3(path, "utf8");
+  return content.split("\n").some((line) => line.trim() === ".env" || line.trim().startsWith(".env"));
+}
+function verifyProjectHealth(cwd) {
+  const lines = [];
+  let ok = true;
+  if (cursorignoreCoversEnv(cwd)) {
+    lines.push("\u2713 Secret settings file hidden from your assistant (.cursorignore)");
+  } else {
+    ok = false;
+    lines.push(
+      "\u2717 Add `.cursorignore` with `.env` listed \u2014 keeps secret values out of your assistant"
+    );
+  }
+  if (gitignoreCoversEnv(cwd)) {
+    lines.push("\u2713 Secret settings file excluded from git (.gitignore)");
+  } else {
+    ok = false;
+    lines.push("\u2717 `.gitignore` must list `.env` so secrets are never committed");
+  }
+  return { ok, lines };
+}
+function formatProjectHealthReport(report) {
+  return report.lines;
+}
+
+// src/doctor/storage-r2.ts
+import { spawnSync } from "child_process";
+import { readFileSync as readFileSync4 } from "fs";
+import { join as join4 } from "path";
+function sanitizeBucketName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
+}
+function readProjectName(cwd) {
+  try {
+    const pkg = JSON.parse(readFileSync4(join4(cwd, "package.json"), "utf8"));
+    if (pkg.name && pkg.name !== "my-vybekiit-app") {
+      return sanitizeBucketName(pkg.name);
+    }
+  } catch {
+  }
+  return "vybekiit-app";
+}
+function wranglerOk(args) {
+  return spawnSync("wrangler", [...args], { stdio: "ignore" }).status === 0;
+}
+async function createR2ApiToken(accountId, apiToken, bucketName) {
+  const response = await fetch(
+    `https://api.cloudflare.com/client/v4/accounts/${accountId}/r2/tokens`,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        name: `vybekiit-${bucketName}`,
+        permissions: {
+          objects: { read: true, write: true }
+        }
+      })
+    }
+  );
+  if (!response.ok) {
+    return null;
+  }
+  const json = await response.json();
+  if (!(json.success && json.result?.access_key_id && json.result?.secret_access_key)) {
+    return null;
+  }
+  return {
+    accessKeyId: json.result.access_key_id,
+    secretAccessKey: json.result.secret_access_key
+  };
+}
+async function provisionR2Storage(cwd, env, log) {
+  const hosting = env.HOSTING_PROVIDER ?? "cloudflare";
+  if (hosting !== "cloudflare") {
+    return { ok: true, message: "R2 provisioning skipped \u2014 hosting is not Cloudflare." };
+  }
+  if (env.R2_BUCKET && env.R2_ACCESS_KEY_ID && env.R2_SECRET_ACCESS_KEY && env.R2_PUBLIC_URL) {
+    return { ok: true, message: "R2 storage already configured." };
+  }
+  const accountId = env.CLOUDFLARE_ACCOUNT_ID;
+  const apiToken = env.CLOUDFLARE_API_TOKEN;
+  if (!(accountId && apiToken)) {
+    return {
+      ok: false,
+      message: "Cloudflare account ID and API token are required before R2 can be set up."
+    };
+  }
+  if (!wranglerOk(["whoami"])) {
+    return { ok: false, message: "wrangler is not signed in \u2014 run wrangler login first." };
+  }
+  const bucketName = env.R2_BUCKET ?? `${readProjectName(cwd)}-assets`;
+  if (!wranglerOk(["r2", "bucket", "list"])) {
+    return { ok: false, message: "Could not list R2 buckets \u2014 check wrangler auth." };
+  }
+  if (wranglerOk(["r2", "bucket", "create", bucketName])) {
+    log.log(`[doctor] Created R2 bucket "${bucketName}".`);
+  } else {
+    const exists = wranglerOk(["r2", "bucket", "list"]);
+    if (!exists) {
+      return { ok: false, message: `Could not create R2 bucket "${bucketName}".` };
+    }
+    log.log(`[doctor] R2 bucket "${bucketName}" already exists or create skipped.`);
+  }
+  let accessKeyId = env.R2_ACCESS_KEY_ID;
+  let secretAccessKey = env.R2_SECRET_ACCESS_KEY;
+  if (!(accessKeyId && secretAccessKey)) {
+    const token = await createR2ApiToken(accountId, apiToken, bucketName);
+    if (!token) {
+      return {
+        ok: false,
+        message: "Could not create R2 API token \u2014 check Cloudflare API token permissions."
+      };
+    }
+    accessKeyId = token.accessKeyId;
+    secretAccessKey = token.secretAccessKey;
+  }
+  const publicUrl = env.R2_PUBLIC_URL ?? `https://${accountId}.r2.cloudflarestorage.com/${bucketName}`;
+  writeEnvKeys(cwd, {
+    STORAGE_PROVIDER: "r2",
+    R2_ACCOUNT_ID: accountId,
+    R2_BUCKET: bucketName,
+    R2_ACCESS_KEY_ID: accessKeyId,
+    R2_SECRET_ACCESS_KEY: secretAccessKey,
+    R2_PUBLIC_URL: publicUrl
+  });
+  return { ok: true, message: `R2 storage ready (bucket: ${bucketName}).` };
+}
+
+// src/doctor/product-surface.ts
+function formatProductSurfaceHints(env) {
+  const lines = [];
+  if (env.JOBS_PROVIDER === "cloudflare" && !env.CLOUDFLARE_QUEUE_NAME) {
+    lines.push(
+      "[doctor] background jobs: add CLOUDFLARE_QUEUE_NAME (or use local jobs until go-live)"
+    );
+  }
+  if (env.KV_PROVIDER === "cloudflare" && !env.CLOUDFLARE_KV_NAMESPACE_ID) {
+    lines.push("[doctor] fast storage: add CLOUDFLARE_KV_NAMESPACE_ID for Cloudflare KV");
+  }
+  if (env.ANALYTICS_PROVIDER === "plausible" && !env.PLAUSIBLE_DOMAIN) {
+    lines.push("[doctor] visitor stats: add PLAUSIBLE_DOMAIN (or analytics stays local no-op)");
+  }
+  if (env.AI_PROVIDER === "openai" && !env.OPENAI_API_KEY) {
+    lines.push(
+      "[doctor] AI features: add OPENAI_API_KEY (or AI stays local mock until you add keys)"
+    );
+  }
+  if (env.NOTIFICATIONS_PROVIDER === "expo") {
+    lines.push(
+      "[doctor] push notifications: Expo push works; email channel needs setup-email first"
+    );
+  }
+  if (lines.length === 0) {
+    lines.push(
+      "[doctor] product surface packages: env looks ready (analytics, jobs, kv, AI, notifications)"
+    );
+  }
+  return lines;
+}
+
+// src/doctor/toolchain.ts
+var GH = {
+  name: "gh",
+  purpose: "download your app's starter files and sign you in to GitHub",
+  versionArgs: ["--version"],
+  install: {
+    darwin: { command: "brew", args: ["install", "gh"], requires: "Homebrew" },
+    win32: { command: "scoop", args: ["install", "gh"], requires: "Scoop" },
+    linux: { command: "brew", args: ["install", "gh"], requires: "Homebrew" }
+  },
+  auth: { command: "gh", args: ["auth", "status"], loginHint: "gh auth login --web" }
+};
+var WRANGLER = {
+  name: "wrangler",
+  purpose: "put your app online",
+  versionArgs: ["--version"],
+  install: {
+    darwin: { command: "npm", args: ["install", "-g", "wrangler"] },
+    win32: { command: "npm", args: ["install", "-g", "wrangler"] },
+    linux: { command: "npm", args: ["install", "-g", "wrangler"] }
+  },
+  auth: { command: "wrangler", args: ["whoami"], loginHint: "wrangler login" }
+};
+var VERCEL = {
+  name: "vercel",
+  purpose: "put your app online",
+  versionArgs: ["--version"],
+  install: {
+    darwin: { command: "npm", args: ["install", "-g", "vercel"] },
+    win32: { command: "npm", args: ["install", "-g", "vercel"] },
+    linux: { command: "npm", args: ["install", "-g", "vercel"] }
+  },
+  auth: { command: "vercel", args: ["whoami"], loginHint: "vercel login" }
+};
+var SUPABASE = {
+  name: "supabase",
+  purpose: "create and manage your database",
+  versionArgs: ["--version"],
+  install: {
+    darwin: { command: "brew", args: ["install", "supabase/tap/supabase"], requires: "Homebrew" },
+    win32: { command: "scoop", args: ["install", "supabase"], requires: "Scoop" },
+    linux: { command: "brew", args: ["install", "supabase/tap/supabase"], requires: "Homebrew" }
+  },
+  auth: { command: "supabase", args: ["projects", "list"], loginHint: "supabase login" }
+};
+var ATLAS = {
+  name: "atlas",
+  purpose: "create and manage your database",
+  versionArgs: ["--version"],
+  install: {
+    darwin: { command: "brew", args: ["install", "mongodb-atlas-cli"], requires: "Homebrew" },
+    win32: { command: "scoop", args: ["install", "mongodb-atlas-cli"], requires: "Scoop" },
+    linux: { command: "brew", args: ["install", "mongodb-atlas-cli"], requires: "Homebrew" }
+  },
+  auth: { command: "atlas", args: ["auth", "whoami"], loginHint: "atlas auth login" }
+};
+var AWS = {
+  name: "aws",
+  purpose: "create and manage your cloud services",
+  versionArgs: ["--version"],
+  install: {
+    darwin: { command: "brew", args: ["install", "awscli"], requires: "Homebrew" },
+    win32: { command: "scoop", args: ["install", "aws"], requires: "Scoop" },
+    linux: { command: "brew", args: ["install", "awscli"], requires: "Homebrew" }
+  },
+  auth: { command: "aws", args: ["sts", "get-caller-identity"], loginHint: "aws configure" }
+};
+var GCLOUD = {
+  name: "gcloud",
+  purpose: "set up sign in with Google for your app",
+  versionArgs: ["--version"],
+  install: {
+    // `--cask` because gcloud ships as a community cask, not a formula (the file's first cask).
+    darwin: { command: "brew", args: ["install", "--cask", "gcloud-cli"], requires: "Homebrew" },
+    win32: { command: "scoop", args: ["install", "gcloud"], requires: "Scoop" },
+    linux: { command: "brew", args: ["install", "--cask", "gcloud-cli"], requires: "Homebrew" }
+  },
+  // `auth list` exits non-zero / prints nothing without an active account; login is the browser flow.
+  auth: { command: "gcloud", args: ["auth", "list"], loginHint: "gcloud auth login" }
+};
+var CLAUDE = {
+  name: "claude",
+  purpose: "your AI coding assistant (Claude Code)",
+  versionArgs: ["--version"],
+  install: {
+    darwin: { command: "npm", args: ["install", "-g", "@anthropic-ai/claude-code"] },
+    win32: { command: "npm", args: ["install", "-g", "@anthropic-ai/claude-code"] },
+    linux: { command: "npm", args: ["install", "-g", "@anthropic-ai/claude-code"] }
+  }
+};
+var CODEX = {
+  name: "codex",
+  purpose: "your AI coding assistant (OpenAI Codex)",
+  versionArgs: ["--version"],
+  install: {
+    darwin: { command: "npm", args: ["install", "-g", "@openai/codex"] },
+    win32: { command: "npm", args: ["install", "-g", "@openai/codex"] },
+    linux: { command: "npm", args: ["install", "-g", "@openai/codex"] }
+  }
+};
+var SKILLS = {
+  name: "skills",
+  purpose: "install the official platform skills your app needs",
+  versionArgs: ["--version"],
+  install: {
+    darwin: { command: "npm", args: ["install", "-g", "skills"] },
+    win32: { command: "npm", args: ["install", "-g", "skills"] },
+    linux: { command: "npm", args: ["install", "-g", "skills"] }
+  }
+};
+var AGENT_TOOLS = [CLAUDE, CODEX, SKILLS];
+var EAS = {
+  name: "eas",
+  purpose: "build your app for the app stores",
+  versionArgs: ["--version"],
+  install: {
+    darwin: { command: "npm", args: ["install", "-g", "eas-cli"] },
+    win32: { command: "npm", args: ["install", "-g", "eas-cli"] },
+    linux: { command: "npm", args: ["install", "-g", "eas-cli"] }
+  },
+  auth: { command: "eas", args: ["whoami"], loginHint: "eas login" }
+};
+var LAUNCH = {
+  name: "launch",
+  purpose: "publish your app to the app stores",
+  versionArgs: ["--version"],
+  install: {
+    darwin: { command: "npm", args: ["install", "-g", "launch-store"] },
+    win32: { command: "npm", args: ["install", "-g", "launch-store"] },
+    linux: { command: "npm", args: ["install", "-g", "launch-store"] }
+  }
+};
+var TOOLCHAIN = [GH, WRANGLER, SUPABASE];
+function selectToolchain(env, options = {}) {
+  const usesAws = env.DATA_PROVIDER === "aws" || env.STORAGE_PROVIDER === "s3" || env.EMAIL_PROVIDER === "ses" || env.AUTH_PROVIDER === "cognito" || env.HOSTING_PROVIDER === "aws";
+  const tools = [];
+  const add = (tool) => {
+    if (!tools.includes(tool)) {
+      tools.push(tool);
+    }
+  };
+  add(GH);
+  add(env.HOSTING_PROVIDER === "aws" ? AWS : env.HOSTING_PROVIDER === "vercel" ? VERCEL : WRANGLER);
+  switch (env.DATA_PROVIDER) {
+    case "mongodb":
+      add(ATLAS);
+      break;
+    case "aws":
+      add(AWS);
+      break;
+    default:
+      add(SUPABASE);
+  }
+  if (usesAws) {
+    add(AWS);
+  }
+  if (options.wantsGoogleAuth || env.GOOGLE_OAUTH_CLIENT_ID) {
+    add(GCLOUD);
+  }
+  if (options.mobile) {
+    add(EAS);
+    add(LAUNCH);
+  }
+  return tools;
+}
+function mergeAgentAndProviderTools(providerTools) {
+  const merged = [];
+  const add = (tool) => {
+    if (!merged.some((t) => t.name === tool.name)) {
+      merged.push(tool);
+    }
+  };
+  for (const tool of AGENT_TOOLS) {
+    add(tool);
+  }
+  for (const tool of providerTools) {
+    add(tool);
+  }
+  return merged;
+}
+function isAgentRuntimeReady(reports) {
+  const claude = reports.find((r) => r.tool === "claude");
+  const codex = reports.find((r) => r.tool === "codex");
+  return Boolean(claude?.installed || codex?.installed);
+}
+function isSkillsCliReady(reports) {
+  return reports.find((r) => r.tool === "skills")?.installed ?? false;
+}
+function planInstall(platform, presence, tools = TOOLCHAIN) {
+  const missing = new Set(presence.filter((p) => !p.present).map((p) => p.tool));
+  return tools.filter((tool) => missing.has(tool.name)).map((tool) => ({ tool: tool.name, ...tool.install[platform] }));
+}
+function formatReport(reports) {
+  return reports.map((report) => {
+    if (!report.installed) {
+      const fix = report.missingRequirement ? ` Install ${report.missingRequirement} first, then re-run.` : " Re-run to try again.";
+      return `\u2717 ${report.tool} \u2014 couldn't be set up (needed to ${report.purpose}).${fix}`;
+    }
+    if (report.authed === false) {
+      return `\u2192 ${report.tool} \u2014 installed, but you're not signed in yet. One-time: run \`${report.loginHint}\`.`;
+    }
+    return `\u2713 ${report.tool} \u2014 ready (used to ${report.purpose}).`;
+  });
+}
+
+// src/doctor/run.ts
+function toPlatform(platform) {
+  return platform === "darwin" || platform === "win32" || platform === "linux" ? platform : null;
+}
+function isMobileProject(dir) {
+  for (const file of ["app.json", "app.config.json"]) {
+    const path = join5(dir, file);
+    if (!existsSync4(path)) {
+      continue;
+    }
+    try {
+      const config = JSON.parse(readFileSync5(path, "utf8"));
+      if (typeof config === "object" && config !== null && "expo" in config) {
+        return true;
+      }
+    } catch {
+    }
+  }
+  return false;
+}
+function isExtensionProject(dir) {
+  return existsSync4(join5(dir, "wxt.config.ts"));
+}
+function reportModeEnvKeys(cwd, assistant) {
+  if (isMobileProject(cwd)) {
+    return { EXPO_PUBLIC_VYBE_ASSISTANT: assistant };
+  }
+  if (isExtensionProject(cwd)) {
+    return { WXT_PUBLIC_VYBE_ASSISTANT: assistant };
+  }
+  return { VYBE_ASSISTANT: assistant };
+}
+function isCursorSession() {
+  return Boolean(process.env.CURSOR_TRACE_ID || process.env.CURSOR_SESSION_ID);
+}
+function succeeds(command, args) {
+  return spawnSync2(command, [...args], { stdio: "ignore" }).status === 0;
+}
+function errorCode(error) {
+  return error && "code" in error && typeof error.code === "string" ? error.code : void 0;
+}
+function runInstall(action, log) {
+  log.log(`[doctor] setting up ${action.tool}: ${action.command} ${action.args.join(" ")}`);
+  const result = spawnSync2(action.command, [...action.args], { stdio: "inherit" });
+  if (errorCode(result.error) === "ENOENT") {
+    return action.requires ? { ok: false, missingRequirement: action.requires } : { ok: false };
+  }
+  return { ok: result.status === 0 };
+}
+function buildReport(tool, presence, installs) {
+  const wasPresent = presence.find((p) => p.tool === tool.name)?.present ?? false;
+  const install = installs.get(tool.name);
+  const installed = wasPresent || install?.ok === true;
+  if (!installed) {
+    const requirement = install?.missingRequirement;
+    return {
+      tool: tool.name,
+      purpose: tool.purpose,
+      installed: false,
+      authed: null,
+      ...requirement ? { missingRequirement: requirement } : {}
+    };
+  }
+  if (!tool.auth) {
+    return { tool: tool.name, purpose: tool.purpose, installed: true, authed: null };
+  }
+  const authed = succeeds(tool.auth.command, tool.auth.args);
+  return {
+    tool: tool.name,
+    purpose: tool.purpose,
+    installed: true,
+    authed,
+    ...authed ? {} : { loginHint: tool.auth.loginHint }
+  };
+}
+async function runDoctor(log = console) {
+  const platform = toPlatform(process.platform);
+  if (!platform) {
+    log.error(`[doctor] This operating system (${process.platform}) isn't supported yet.`);
+    return 1;
+  }
+  const cwd = process.cwd();
+  const env = mergeEnv(process.env, loadEnvFile(cwd));
+  const providerTools = selectToolchain(env, {
+    mobile: isMobileProject(cwd),
+    wantsGoogleAuth: Boolean(env.GOOGLE_OAUTH_CLIENT_ID)
+  });
+  const toolchain = mergeAgentAndProviderTools(providerTools);
+  if (isCursorSession()) {
+    log.log("\u2713 Cursor \u2014 you're in Cursor; no separate agent install needed.");
+  }
+  const presence = toolchain.map((tool) => ({
+    tool: tool.name,
+    present: succeeds(tool.name, tool.versionArgs)
+  }));
+  const installs = /* @__PURE__ */ new Map();
+  for (const action of planInstall(platform, presence, toolchain)) {
+    installs.set(action.tool, runInstall(action, log));
+  }
+  const reports = toolchain.map((tool) => buildReport(tool, presence, installs));
+  for (const line of formatReport(reports)) {
+    log.log(line);
+  }
+  const skillsReport = verifyPlatformSkills(cwd);
+  for (const line of formatPlatformSkillsReport(skillsReport)) {
+    log.log(line);
+  }
+  const projectHealth = verifyProjectHealth(cwd);
+  for (const line of formatProjectHealthReport(projectHealth)) {
+    log.log(line);
+  }
+  const r2Result = await provisionR2Storage(cwd, env, log);
+  log.log(`[doctor] ${r2Result.message}`);
+  for (const line of formatProductSurfaceHints(env)) {
+    log.log(line);
+  }
+  const cloudReady = providerTools.every((tool) => {
+    const report = reports.find((r) => r.tool === tool.name);
+    return report?.installed === true;
+  });
+  const cursorSession = isCursorSession();
+  const agentReady = isAgentRuntimeReady(reports) || cursorSession;
+  const skillsReady = isSkillsCliReady(reports);
+  const assistant = inferVybeAssistant({
+    cursorSession,
+    claudeInstalled: reports.find((r) => r.tool === "claude")?.installed === true,
+    codexInstalled: reports.find((r) => r.tool === "codex")?.installed === true
+  });
+  if (assistant) {
+    writeEnvKeys(cwd, reportModeEnvKeys(cwd, assistant));
+    log.log(`\u2713 Report Mode \u2014 your assistant is set to ${assistant}.`);
+  }
+  return cloudReady && r2Result.ok && agentReady && skillsReady && projectHealth.ok ? 0 : 1;
+}
+
+// src/resolve-templates.ts
+import { execFile } from "child_process";
+import { access as access2, mkdtemp, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { dirname, join as join7, resolve } from "path";
+import process2 from "process";
+import { fileURLToPath } from "url";
+import { promisify } from "util";
+
+// src/scaffold.ts
+import { access, cp, readdir, readFile, writeFile } from "fs/promises";
+import { basename, join as join6 } from "path";
+
+// src/rewrite-deps.ts
+function rewriteWorkspaceDeps(deps, version) {
+  const rewritten = {};
+  for (const [name, range] of Object.entries(deps)) {
+    const isVybeKiitWorkspace = name.startsWith("@vybekiit/") && range.startsWith("workspace:");
+    rewritten[name] = isVybeKiitWorkspace ? `^${version}` : range;
+  }
+  return rewritten;
+}
+
+// src/scaffold.ts
+var TEMPLATES = ["web", "mobile", "extension"];
+var ScaffoldError = class extends Error {
+};
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".next", "dist", ".turbo", ".git"]);
+function isTemplateName(value) {
+  return TEMPLATES.includes(value);
+}
+async function pinScaffoldedDeps(dest, packagesVersion) {
+  const pkgPath = join6(dest, "package.json");
+  let raw;
+  try {
+    raw = await readFile(pkgPath, "utf8");
+  } catch {
+    return;
+  }
+  const pkg = JSON.parse(raw);
+  for (const field of ["dependencies", "devDependencies"]) {
+    const deps = pkg[field];
+    if (deps && typeof deps === "object") {
+      pkg[field] = rewriteWorkspaceDeps(deps, packagesVersion);
+    }
+  }
+  await writeFile(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`);
+}
+async function scaffold(options) {
+  const sourceDir = join6(options.source, options.template);
+  try {
+    await access(sourceDir);
+  } catch {
+    throw new ScaffoldError(`Template "${options.template}" was not found at ${sourceDir}.`);
+  }
+  try {
+    const existing = await readdir(options.dest);
+    if (existing.length > 0) {
+      throw new ScaffoldError(`Destination ${options.dest} already exists and is not empty.`);
+    }
+  } catch (error) {
+    if (error instanceof ScaffoldError) {
+      throw error;
+    }
+  }
+  await cp(sourceDir, options.dest, {
+    recursive: true,
+    filter: (src) => !SKIP_DIRS.has(basename(src))
+  });
+  await pinScaffoldedDeps(options.dest, options.packagesVersion);
+  return { dest: options.dest };
+}
+
+// src/resolve-templates.ts
+var execFileAsync = promisify(execFile);
+var HERE = dirname(fileURLToPath(import.meta.url));
+var MIRROR_ORG = "VybeKiit";
+async function pathExists(path) {
+  try {
+    await access2(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function cloneMirror(template, targetDir) {
+  try {
+    await execFileAsync("gh", [
+      "repo",
+      "clone",
+      `${MIRROR_ORG}/${template}`,
+      targetDir,
+      "--",
+      "--depth",
+      "1",
+      "--no-tags"
+    ]);
+  } catch {
+    throw new ScaffoldError(
+      `Couldn't download the ${template} template. Make sure your assistant is signed in to GitHub \u2014 run: gh auth login --web`
+    );
+  }
+}
+async function resolveTemplatesSource(template, deps = { clone: cloneMirror, exists: pathExists }) {
+  const override = process2.env.VYBEKIIT_TEMPLATES_DIR;
+  if (override) {
+    return { source: override };
+  }
+  const localRoot = resolve(HERE, "..", "..", "templates");
+  if (await deps.exists(join7(localRoot, template))) {
+    return { source: localRoot };
+  }
+  const tempRoot = await mkdtemp(join7(tmpdir(), "vybekiit-"));
+  try {
+    await deps.clone(template, join7(tempRoot, template));
+  } catch (error) {
+    await rm(tempRoot, { recursive: true, force: true });
+    throw error;
+  }
+  return { source: tempRoot, cleanup: () => rm(tempRoot, { recursive: true, force: true }) };
+}
+
+// src/sync-agent-layer.ts
+import { execFile as execFile2 } from "child_process";
+import { access as access3, cp as cp2, readFile as readFile2 } from "fs/promises";
+import { join as join8 } from "path";
+import process3 from "process";
+import { promisify as promisify2 } from "util";
+import {
+  AGENT_LAYER_PATHS,
+  formatAgentLayerSyncSummary,
+  planAgentLayerSync
+} from "@vybekiit/agent-kit";
+var execFileAsync2 = promisify2(execFile2);
+var defaultDeps = {
+  resolve: resolveTemplatesSource,
+  copy: cp2,
+  runSkillsUpdate: async (cwd) => {
+    await execFileAsync2("npx", ["skills", "update", "-y"], { cwd, env: process3.env });
+  },
+  pathExists: async (path) => {
+    try {
+      await access3(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+async function detectTemplateName(cwd) {
+  try {
+    const raw = await readFile2(join8(cwd, "package.json"), "utf8");
+    const pkg = JSON.parse(raw);
+    if (pkg.dependencies?.expo || pkg.main?.includes("expo-router")) {
+      return "mobile";
+    }
+    if (pkg.dependencies?.next) {
+      return "web";
+    }
+  } catch {
+  }
+  try {
+    await access3(join8(cwd, ".vybekiit/skills/publish-extension.md"));
+    return "extension";
+  } catch {
+    return "web";
+  }
+}
+async function listMirrorAgentPaths(mirrorRoot, pathExists2) {
+  const found = [];
+  for (const path of AGENT_LAYER_PATHS) {
+    if (await pathExists2(join8(mirrorRoot, path))) {
+      found.push(path);
+    }
+  }
+  return found;
+}
+async function runSyncAgentLayer(args, cwd = process3.cwd(), deps = defaultDeps) {
+  const explicit = args[0];
+  const template = explicit && isTemplateName(explicit) ? explicit : await detectTemplateName(cwd);
+  if (!template) {
+    return {
+      lines: ["Could not tell which template this project uses. Pass: web, mobile, or extension."],
+      exitCode: 1
+    };
+  }
+  let cleanup;
+  try {
+    const resolved = await deps.resolve(template, {
+      clone: cloneMirror,
+      exists: deps.pathExists
+    });
+    cleanup = resolved.cleanup;
+    const mirrorRoot = join8(resolved.source, template);
+    const mirrorPaths = await listMirrorAgentPaths(mirrorRoot, deps.pathExists);
+    const plan = planAgentLayerSync(mirrorPaths);
+    const lines = [formatAgentLayerSyncSummary(plan)];
+    for (const path of plan.pathsToSync) {
+      const src = join8(mirrorRoot, path);
+      const dest = join8(cwd, path);
+      await deps.copy(src, dest, { recursive: true, force: true });
+    }
+    if (await deps.pathExists(join8(cwd, "skills-lock.json"))) {
+      try {
+        await deps.runSkillsUpdate(cwd);
+        lines.push("Updated your assistant\u2019s platform instruction files.");
+      } catch {
+        lines.push("Could not refresh platform instruction files \u2014 try again later.");
+      }
+    }
+    lines.push("Done \u2014 your assistant has the latest instructions.");
+    return { lines, exitCode: 0 };
+  } catch (error) {
+    if (error instanceof ScaffoldError) {
+      return { lines: [error.message], exitCode: 1 };
+    }
+    throw error;
+  } finally {
+    await cleanup?.();
+  }
+}
+
+// src/index.ts
+var HERE2 = dirname2(fileURLToPath2(import.meta.url));
+async function readVersion() {
+  try {
+    const raw = await readFile3(join9(HERE2, "..", "package.json"), "utf8");
+    return JSON.parse(raw).version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+async function runNew(args) {
+  const [template, dir] = args;
+  if (!(template && isTemplateName(template))) {
+    return 1;
+  }
+  const dest = resolve2(process4.cwd(), dir ?? template);
+  let cleanup;
+  try {
+    const resolved = await resolveTemplatesSource(template);
+    cleanup = resolved.cleanup;
+    await scaffold({
+      template,
+      source: resolved.source,
+      dest,
+      packagesVersion: await readVersion()
+    });
+  } catch (error) {
+    if (error instanceof ScaffoldError) {
+      return 1;
+    }
+    throw error;
+  } finally {
+    await cleanup?.();
+  }
+  return 0;
+}
+async function main(argv) {
+  const [command, ...rest] = argv;
+  if (!command || command === "help" || command === "--help" || command === "-h") {
+    return 0;
+  }
+  if (command === "--version" || command === "-v") {
+    return 0;
+  }
+  if (command === "new") {
+    return runNew(rest);
+  }
+  if (command === "doctor") {
+    return await runDoctor();
+  }
+  if (command === "sync-agent-layer") {
+    const result = await runSyncAgentLayer(rest);
+    for (const _line of result.lines) {
+    }
+    return result.exitCode;
+  }
+  return 1;
+}
+if (process4.argv[1] && resolve2(process4.argv[1]) === fileURLToPath2(import.meta.url)) {
+  main(process4.argv.slice(2)).then((code) => process4.exit(code)).catch((_error) => {
+    process4.exit(1);
+  });
+}
+export {
+  cloneMirror,
+  resolveTemplatesSource
+};

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "vybekiit",
+  "version": "0.1.0",
+  "description": "Scaffold a VybeKiit template into your own repo: `npx vybekiit new web my-app`.",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "bin": {
+    "vybekiit": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@vybekiit/agent-kit": "0.1.0",
+    "@vybekiit/report-mode": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}