create-githat-app 1.3.0 → 1.4.1

package/dist/cli.js

@@ -1,9 +1,9 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 
 // src/cli.ts
-import { Command } from "commander";
-import * as p8 from "@clack/prompts";
-import chalk3 from "chalk";
+import { Command as Command7 } from "commander";
+import * as p12 from "@clack/prompts";
+import chalk10 from "chalk";
 
 // src/utils/ascii.ts
 import figlet from "figlet";
@@ -11,7 +11,7 @@ import gradient from "gradient-string";
 import chalk from "chalk";
 
 // src/constants.ts
-var VERSION = "1.3.0";
+var VERSION = "1.0.17";
 var DEFAULT_API_URL = "https://api.githat.io";
 var DASHBOARD_URL = "https://githat.io/dashboard/apps";
 var BRAND_COLORS = ["#7c3aed", "#6366f1", "#8b5cf6"];
@@ -21,7 +21,8 @@ var DEPS = {
       next: "^16.0.0",
       react: "^19.0.0",
       "react-dom": "^19.0.0",
-      "@githat/nextjs": "^0.4.0"
+      "@githat/nextjs": "^0.8.2",
+      "@githat/ui": "^1.0.0"
     },
     devDependencies: {
       typescript: "^5.9.0",
@@ -35,7 +36,8 @@ var DEPS = {
       react: "^19.0.0",
       "react-dom": "^19.0.0",
       "react-router-dom": "^7.0.0",
-      "@githat/nextjs": "^0.4.0"
+      "@githat/nextjs": "^0.8.2",
+      "@githat/ui": "^1.0.0"
     },
     devDependencies: {
       vite: "^7.0.0",
@@ -73,6 +75,48 @@ var DEPS = {
   "drizzle-sqlite": {
     dependencies: { "drizzle-orm": "^0.39.0", "better-sqlite3": "^11.0.0" },
     devDependencies: { "drizzle-kit": "^0.30.0", "@types/better-sqlite3": "^7.6.0" }
+  },
+  // Backend frameworks for fullstack
+  hono: {
+    dependencies: {
+      hono: "^4.6.0",
+      "@hono/node-server": "^1.13.0"
+    },
+    devDependencies: {
+      typescript: "^5.9.0",
+      "@types/node": "^22.0.0",
+      tsx: "^4.19.0"
+    }
+  },
+  express: {
+    dependencies: {
+      express: "^5.0.0",
+      cors: "^2.8.5"
+    },
+    devDependencies: {
+      typescript: "^5.9.0",
+      "@types/node": "^22.0.0",
+      "@types/express": "^5.0.0",
+      "@types/cors": "^2.8.17",
+      tsx: "^4.19.0"
+    }
+  },
+  fastify: {
+    dependencies: {
+      fastify: "^5.2.0",
+      "@fastify/cors": "^10.0.0"
+    },
+    devDependencies: {
+      typescript: "^5.9.0",
+      "@types/node": "^22.0.0",
+      tsx: "^4.19.0"
+    }
+  },
+  // Turborepo for fullstack monorepo
+  turbo: {
+    devDependencies: {
+      turbo: "^2.3.0"
+    }
   }
 };
 
@@ -123,30 +167,61 @@ function sectionHeader(title) {
   console.log(dim(`  \u2500\u2500\u2500 ${title} ${"\u2500".repeat(lineLen)}`));
   console.log("");
 }
-function displaySuccess(projectName, packageManager, framework) {
+function keyNextSteps() {
+  return [
+    chalk.bold("Next:") + " add your GitHat key",
+    `  1. Open ${violet(".env.local")}`,
+    `  2. Paste your key from ${violet("https://githat.io/dashboard/apps")}`,
+    `  3. Run ${violet("npm run dev")} again`,
+    dim("   (.env.local is gitignored \u2014 your key never gets committed.)"),
+    ""
+  ];
+}
+function displaySuccess(projectName, packageManager, framework, hasPublishableKey = true, isFullstack = false) {
   const devCmd = packageManager === "npm" ? "npm run dev" : `${packageManager} dev`;
   const port = framework === "react-vite" ? "5173" : "3000";
   console.log("");
-  drawBox([
-    `${violet("\u2726")}  Your GitHat app is ready!`,
-    "",
-    `${violet("$")} cd ${projectName}`,
-    `${violet("$")} ${devCmd}`,
-    "",
-    dim(`\u2192 http://localhost:${port}`),
-    "",
-    chalk.bold("Routes"),
-    `${violet("/sign-in")}       Sign in`,
-    `${violet("/sign-up")}       Create account`,
-    `${violet("/dashboard")}     Protected dashboard`,
-    "",
-    dim("Docs \u2192 https://githat.io/docs/sdk")
-  ]);
+  if (isFullstack) {
+    drawBox([
+      `${violet("\u2726")}  Your GitHat fullstack app is ready!`,
+      "",
+      `${violet("$")} cd ${projectName}`,
+      `${violet("$")} ${devCmd}`,
+      "",
+      dim(`\u2192 Web: http://localhost:3000`),
+      dim(`\u2192 API: http://localhost:3001`),
+      "",
+      chalk.bold("Structure"),
+      `${violet("apps/web")}       Next.js frontend`,
+      `${violet("apps/api")}       API backend`,
+      `${violet("packages/")}      Shared code`,
+      "",
+      ...hasPublishableKey ? [] : keyNextSteps(),
+      dim("Docs \u2192 https://githat.io/docs/sdk")
+    ]);
+  } else {
+    drawBox([
+      `${violet("\u2726")}  Your GitHat app is ready!`,
+      "",
+      `${violet("$")} cd ${projectName}`,
+      `${violet("$")} ${devCmd}`,
+      "",
+      dim(`\u2192 http://localhost:${port}`),
+      "",
+      chalk.bold("Routes"),
+      `${violet("/sign-in")}       Sign in`,
+      `${violet("/sign-up")}       Create account`,
+      `${violet("/dashboard")}     Protected dashboard`,
+      "",
+      ...hasPublishableKey ? [] : keyNextSteps(),
+      dim("Docs \u2192 https://githat.io/docs/sdk")
+    ]);
+  }
   console.log("");
 }
 
 // src/prompts/index.ts
-import * as p6 from "@clack/prompts";
+import * as p8 from "@clack/prompts";
 
 // src/prompts/project.ts
 import * as p from "@clack/prompts";
@@ -183,6 +258,11 @@ async function promptProject(initialName) {
         message: "Display name",
         placeholder: "Acme Corp",
         validate: (v) => !v ? "Display name is required" : void 0
+      }),
+      githubUsername: () => p.text({
+        message: "GitHub username",
+        placeholder: "your-github-handle",
+        hint: "Used in CODEOWNERS \u2014 you can change it later"
       })
     },
     {
@@ -195,12 +275,46 @@ async function promptProject(initialName) {
   return {
     projectName: answers.projectName,
     businessName: answers.businessName,
-    description: `${answers.businessName} \u2014 Built with GitHat`
+    description: `${answers.businessName} \u2014 Built with GitHat`,
+    githubUsername: answers.githubUsername || ""
   };
 }
 
-// src/prompts/framework.ts
+// src/prompts/project-type.ts
 import * as p2 from "@clack/prompts";
+async function promptProjectType() {
+  const answers = await p2.group(
+    {
+      projectType: () => p2.select({
+        message: "Project type",
+        options: [
+          {
+            value: "frontend",
+            label: "Frontend only",
+            hint: "Next.js or React+Vite"
+          },
+          {
+            value: "fullstack",
+            label: "Fullstack",
+            hint: "Next.js + API (Turborepo)"
+          }
+        ]
+      })
+    },
+    {
+      onCancel: () => {
+        p2.cancel("Setup cancelled.");
+        process.exit(0);
+      }
+    }
+  );
+  return {
+    projectType: answers.projectType
+  };
+}
+
+// src/prompts/framework.ts
+import * as p3 from "@clack/prompts";
 
 // src/utils/package-manager.ts
 function detectPackageManager() {
@@ -221,18 +335,27 @@ function getInstallCommand(pm) {
 }
 
 // src/prompts/framework.ts
-async function promptFramework(typescriptOverride) {
+async function promptFramework(typescriptOverride, isFullstack) {
   const packageManager = detectPackageManager();
-  const answers = await p2.group(
+  const frameworkOptions = isFullstack ? [{ value: "nextjs", label: "Next.js 16", hint: "App Router \xB7 SSR \xB7 middleware auth" }] : [
+    { value: "plain", label: "Plain", hint: "Auth + a homepage. Smallest possible GitHat app." },
+    { value: "saas", label: "SaaS", hint: "Orgs, teams, RBAC, subscription billing. Replaces Clerk + Stripe." },
+    { value: "marketplace", label: "Marketplace", hint: "Multi-vendor commerce. Anonymous-first, Sebastn Connect." },
+    { value: "content", label: "Content", hint: "Paywalled posts, newsletter. Replaces Substack." },
+    { value: "dashboard", label: "Dashboard", hint: "Auth-gated admin UI over your existing database." },
+    { value: "portfolio", label: "Portfolio", hint: "Personal site: public projects, auth-gated editor." },
+    { value: "classroom", label: "Classroom", hint: "Live student presentations + real-time audience feedback." },
+    { value: "agent", label: "AI Agent", hint: "Web4 wallet-bound agent + MCP server. Public verification." },
+    { value: "nextjs", label: "Next.js (full kit)", hint: "Legacy: dashboard + orgs + agents + MCP scaffolding." },
+    { value: "react-vite", label: "React + Vite", hint: "SPA \xB7 client-side routing." }
+  ];
+  const answers = await p3.group(
     {
-      framework: () => p2.select({
+      framework: () => p3.select({
         message: "Framework",
-        options: [
-          { value: "nextjs", label: "Next.js 16", hint: "App Router \xB7 SSR \xB7 middleware auth" },
-          { value: "react-vite", label: "React 19 + Vite 7", hint: "SPA \xB7 client-side routing" }
-        ]
+        options: frameworkOptions
       }),
-      typescript: () => typescriptOverride !== void 0 ? Promise.resolve(typescriptOverride) : p2.select({
+      typescript: () => typescriptOverride !== void 0 ? Promise.resolve(typescriptOverride) : p3.select({
         message: "Language",
         options: [
           { value: true, label: "TypeScript", hint: "recommended" },
@@ -242,7 +365,7 @@ async function promptFramework(typescriptOverride) {
     },
     {
       onCancel: () => {
-        p2.cancel("Setup cancelled.");
+        p3.cancel("Setup cancelled.");
         process.exit(0);
       }
     }
@@ -254,9 +377,47 @@ async function promptFramework(typescriptOverride) {
   };
 }
 
+// src/prompts/backend.ts
+import * as p4 from "@clack/prompts";
+async function promptBackend() {
+  const answers = await p4.group(
+    {
+      backendFramework: () => p4.select({
+        message: "Backend framework",
+        options: [
+          {
+            value: "hono",
+            label: "Hono",
+            hint: "recommended \xB7 serverless-native \xB7 14KB"
+          },
+          {
+            value: "express",
+            label: "Express",
+            hint: "classic Node.js \xB7 large ecosystem"
+          },
+          {
+            value: "fastify",
+            label: "Fastify",
+            hint: "high performance \xB7 schema validation"
+          }
+        ]
+      })
+    },
+    {
+      onCancel: () => {
+        p4.cancel("Setup cancelled.");
+        process.exit(0);
+      }
+    }
+  );
+  return {
+    backendFramework: answers.backendFramework
+  };
+}
+
 // src/prompts/githat.ts
 import { execSync } from "child_process";
-import * as p3 from "@clack/prompts";
+import * as p5 from "@clack/prompts";
 function openBrowser(url) {
   try {
     const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
@@ -264,52 +425,104 @@ function openBrowser(url) {
   } catch {
   }
 }
+function sleep(ms) {
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+async function deviceAuthFlow() {
+  const spinner2 = p5.spinner();
+  try {
+    spinner2.start("Requesting device code...");
+    const codeRes = await fetch(`${DEFAULT_API_URL}/auth/device/code`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ client_name: "create-githat-app" })
+    });
+    if (!codeRes.ok) {
+      spinner2.stop("Failed to get device code");
+      return null;
+    }
+    const codeData = await codeRes.json();
+    spinner2.stop("Device code generated");
+    p5.note(
+      `Code: ${codeData.user_code}
+
+Opening browser to complete sign-in...
+If it doesn't open, visit: ${codeData.verification_uri_complete}`,
+      "Authorize Device"
+    );
+    openBrowser(codeData.verification_uri_complete);
+    spinner2.start("Waiting for browser authorization...");
+    const expiresAt = Date.now() + codeData.expires_in * 1e3;
+    const pollInterval = (codeData.interval || 5) * 1e3;
+    while (Date.now() < expiresAt) {
+      await sleep(pollInterval);
+      const tokenRes = await fetch(`${DEFAULT_API_URL}/auth/device/token`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ device_code: codeData.device_code })
+      });
+      const tokenData = await tokenRes.json();
+      if (tokenData.error === "authorization_pending") {
+        continue;
+      }
+      if (tokenData.error === "expired_token") {
+        spinner2.stop("Device code expired");
+        p5.log.error("Authorization timed out. Please try again.");
+        return null;
+      }
+      if (tokenData.publishable_key) {
+        spinner2.stop("Authorized!");
+        p5.log.success(`Connected to ${tokenData.app_name || "your app"} (${tokenData.org_name || "your org"})`);
+        return tokenData.publishable_key;
+      }
+      spinner2.stop("Authorization failed");
+      return null;
+    }
+    spinner2.stop("Timed out");
+    p5.log.error("Authorization timed out. Please try again.");
+    return null;
+  } catch (err) {
+    spinner2.stop("Connection error");
+    p5.log.error("Failed to connect to GitHat API. Check your internet connection.");
+    return null;
+  }
+}
 async function promptGitHat(existingKey) {
   let publishableKey = existingKey || "";
   if (!publishableKey) {
-    const connectChoice = await p3.select({
+    const connectChoice = await p5.select({
       message: "Connect to GitHat",
       options: [
-        { value: "browser", label: "Sign in with browser", hint: "opens githat.io \u2014 recommended" },
-        { value: "paste", label: "I have a key", hint: "paste your pk_live_... key" },
-        { value: "skip", label: "Skip for now", hint: "add key to .env later" }
+        { value: "skip", label: "Skip for now", hint: "auth works on localhost \u2014 add key later" },
+        { value: "browser", label: "Sign in with browser", hint: "opens githat.io to authorize" },
+        { value: "paste", label: "I have a key", hint: "paste your pk_live_... key" }
       ]
     });
-    if (p3.isCancel(connectChoice)) {
-      p3.cancel("Setup cancelled.");
+    if (p5.isCancel(connectChoice)) {
+      p5.cancel("Setup cancelled.");
       process.exit(0);
     }
     if (connectChoice === "browser") {
-      p3.log.step("Opening githat.io in your browser...");
-      openBrowser("https://githat.io/sign-up");
-      p3.log.info("Sign up (or sign in), then go to Dashboard \u2192 Apps to copy your key.");
-      const pastedKey = await p3.text({
-        message: "Paste your publishable key",
-        placeholder: "pk_live_...",
-        validate: validatePublishableKey
-      });
-      if (p3.isCancel(pastedKey)) {
-        p3.cancel("Setup cancelled.");
-        process.exit(0);
+      const key = await deviceAuthFlow();
+      if (key) {
+        publishableKey = key;
+      } else {
+        p5.log.warn("Authorization failed. Continuing without key...");
       }
-      publishableKey = pastedKey || "";
     } else if (connectChoice === "paste") {
-      const pastedKey = await p3.text({
+      const pastedKey = await p5.text({
         message: "Publishable key",
         placeholder: `pk_live_... (get one at ${DASHBOARD_URL})`,
         validate: validatePublishableKey
       });
-      if (p3.isCancel(pastedKey)) {
-        p3.cancel("Setup cancelled.");
+      if (p5.isCancel(pastedKey)) {
+        p5.cancel("Setup cancelled.");
         process.exit(0);
       }
       publishableKey = pastedKey || "";
-    } else if (connectChoice === "skip") {
-      p3.log.info("Your app will work on localhost without a key!");
-      p3.log.info("For production, get your key at https://githat.io/dashboard/apps");
     }
   }
-  const authFeatures = await p3.multiselect({
+  const authFeatures = await p5.multiselect({
     message: "Auth features",
     options: [
       { value: "forgot-password", label: "Forgot password", hint: "reset via email" },
@@ -318,11 +531,11 @@ async function promptGitHat(existingKey) {
       { value: "mcp-servers", label: "MCP servers", hint: "Model Context Protocol" },
       { value: "ai-agents", label: "AI agents", hint: "wallet-based identity" }
     ],
-    initialValues: ["forgot-password", "email-verification"],
+    initialValues: ["forgot-password"],
     required: false
   });
-  if (p3.isCancel(authFeatures)) {
-    p3.cancel("Setup cancelled.");
+  if (p5.isCancel(authFeatures)) {
+    p5.cancel("Setup cancelled.");
     process.exit(0);
   }
   return {
@@ -333,11 +546,11 @@ async function promptGitHat(existingKey) {
 }
 
 // src/prompts/features.ts
-import * as p4 from "@clack/prompts";
+import * as p6 from "@clack/prompts";
 async function promptFeatures() {
-  const answers = await p4.group(
+  const answers = await p6.group(
     {
-      databaseChoice: () => p4.select({
+      databaseChoice: () => p6.select({
         message: "Database",
         options: [
           { value: "none", label: "None", hint: "use GitHat backend directly" },
@@ -347,12 +560,12 @@ async function promptFeatures() {
           { value: "drizzle-sqlite", label: "Drizzle + SQLite" }
         ]
       }),
-      useTailwind: () => p4.confirm({ message: "Tailwind CSS?", initialValue: true }),
-      includeDashboard: () => p4.confirm({ message: "Include dashboard?", initialValue: true })
+      useTailwind: () => p6.confirm({ message: "Tailwind CSS?", initialValue: true }),
+      includeDashboard: () => p6.confirm({ message: "Include dashboard?", initialValue: true })
     },
     {
       onCancel: () => {
-        p4.cancel("Setup cancelled.");
+        p6.cancel("Setup cancelled.");
         process.exit(0);
       }
     }
@@ -366,14 +579,14 @@ async function promptFeatures() {
 }
 
 // src/prompts/finalize.ts
-import * as p5 from "@clack/prompts";
+import * as p7 from "@clack/prompts";
 async function promptFinalize() {
-  const installDeps = await p5.confirm({
+  const installDeps = await p7.confirm({
     message: "Install dependencies?",
     initialValue: true
   });
-  if (p5.isCancel(installDeps)) {
-    p5.cancel("Setup cancelled.");
+  if (p7.isCancel(installDeps)) {
+    p7.cancel("Setup cancelled.");
     process.exit(0);
   }
   return {
@@ -383,30 +596,75 @@ async function promptFinalize() {
 }
 
 // src/prompts/index.ts
+function toDisplayName(projectName) {
+  return projectName.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function getDefaults(projectName, publishableKey, typescript, fullstack, backendFramework, template, githubUsername) {
+  const displayName = toDisplayName(projectName);
+  const projectType = fullstack ? "fullstack" : "frontend";
+  const framework = template ?? "nextjs";
+  const isMinimal = template !== void 0;
+  return {
+    projectName,
+    businessName: displayName,
+    description: `${displayName} \u2014 Built with GitHat`,
+    githubUsername: githubUsername || projectName,
+    projectType,
+    backendFramework: fullstack ? backendFramework || "hono" : void 0,
+    framework,
+    typescript: typescript ?? true,
+    packageManager: detectPackageManager(),
+    publishableKey: publishableKey || "",
+    apiUrl: DEFAULT_API_URL,
+    authFeatures: isMinimal ? [] : ["forgot-password"],
+    databaseChoice: "none",
+    useTailwind: true,
+    includeDashboard: !isMinimal,
+    includeGithatFolder: !isMinimal && projectType === "frontend",
+    initGit: true,
+    installDeps: true
+  };
+}
 async function runPrompts(args) {
-  p6.intro("Let\u2019s set up your GitHat app");
+  if (args.yes && args.initialName) {
+    p8.log.info(
+      args.template ? `Using ${args.template} defaults (--yes --${args.template})` : "Using defaults (--yes flag)"
+    );
+    return getDefaults(args.initialName, args.publishableKey, args.typescript, args.fullstack, args.backendFramework, args.template, args.githubUsername);
+  }
+  p8.intro("Let's set up your GitHat app");
   sectionHeader("Project");
   const project = await promptProject(args.initialName);
+  const projectType = await promptProjectType();
   sectionHeader("Stack");
-  const framework = await promptFramework(args.typescript);
+  const isFullstack = projectType.projectType === "fullstack";
+  const framework = await promptFramework(args.typescript, isFullstack);
+  let backend = {};
+  if (isFullstack) {
+    backend = await promptBackend();
+  }
   sectionHeader("Connect");
   const githat = await promptGitHat(args.publishableKey);
   sectionHeader("Features");
   const features = await promptFeatures();
   sectionHeader("Finish");
   const finalize = await promptFinalize();
-  return { ...project, ...framework, ...githat, ...features, ...finalize };
+  return { ...project, ...projectType, ...framework, ...backend, ...githat, ...features, ...finalize };
 }
 function answersToContext(answers) {
   return {
     projectName: answers.projectName,
     businessName: answers.businessName,
     description: answers.description,
+    githubUsername: answers.githubUsername || answers.projectName,
     framework: answers.framework,
     typescript: answers.typescript,
     packageManager: answers.packageManager,
     publishableKey: answers.publishableKey,
     apiUrl: answers.apiUrl,
+    // Project type
+    projectType: answers.projectType,
+    backendFramework: answers.backendFramework,
     useDatabase: answers.databaseChoice !== "none",
     databaseChoice: answers.databaseChoice,
     useTailwind: answers.useTailwind,
@@ -423,11 +681,11 @@ function answersToContext(answers) {
 }
 
 // src/scaffold/index.ts
-import fs3 from "fs-extra";
-import path3 from "path";
+import fs4 from "fs-extra";
+import path4 from "path";
 import { execSync as execSync3 } from "child_process";
-import * as p7 from "@clack/prompts";
-import chalk2 from "chalk";
+import * as p10 from "@clack/prompts";
+import chalk3 from "chalk";
 
 // src/utils/template-engine.ts
 import Handlebars from "handlebars";
@@ -440,6 +698,20 @@ var TEMPLATES_ROOT = path.resolve(__dirname2, "..", "templates");
 Handlebars.registerHelper("ifEquals", function(a, b, options) {
   return a === b ? options.fn(this) : options.inverse(this);
 });
+var NEXT_LIKE = /* @__PURE__ */ new Set([
+  "nextjs",
+  "plain",
+  "saas",
+  "marketplace",
+  "agent",
+  "content",
+  "dashboard",
+  "portfolio",
+  "classroom"
+]);
+Handlebars.registerHelper("ifNext", function(framework, options) {
+  return NEXT_LIKE.has(framework) ? options.fn(this) : options.inverse(this);
+});
 function getTemplatesRoot() {
   return TEMPLATES_ROOT;
 }
@@ -486,15 +758,39 @@ function writeJson(root, relativePath, data) {
 }
 
 // src/scaffold/package-builder.ts
+var NEXT_LIKE2 = /* @__PURE__ */ new Set([
+  "nextjs",
+  "plain",
+  "saas",
+  "marketplace",
+  "agent",
+  "content",
+  "dashboard",
+  "portfolio",
+  "classroom"
+]);
+var MINIMAL = /* @__PURE__ */ new Set([
+  "plain",
+  "saas",
+  "marketplace",
+  "agent",
+  "content",
+  "dashboard",
+  "portfolio",
+  "classroom"
+]);
 function buildPackageJson(ctx) {
-  const isNext = ctx.framework === "nextjs";
+  const isNext = NEXT_LIKE2.has(ctx.framework);
   const deps = {
     ...isNext ? DEPS.nextjs.dependencies : DEPS["react-vite"].dependencies
   };
   const devDeps = {
     ...isNext ? DEPS.nextjs.devDependencies : DEPS["react-vite"].devDependencies
   };
-  if (ctx.useTailwind) {
+  if (MINIMAL.has(ctx.framework)) {
+    delete deps["@githat/ui"];
+  }
+  if (ctx.useTailwind || MINIMAL.has(ctx.framework)) {
     if (isNext) {
       Object.assign(devDeps, DEPS.tailwind.devDependencies);
     } else {
@@ -543,18 +839,18 @@ function sortKeys(obj) {
 
 // src/utils/spinner.ts
 import ora from "ora";
-function createSpinner(text3) {
-  return ora({ text: text3, color: "magenta" });
+function createSpinner(text4) {
+  return ora({ text: text4, color: "magenta" });
 }
-async function withSpinner(text3, fn, successText) {
-  const spinner = createSpinner(text3);
-  spinner.start();
+async function withSpinner(text4, fn, successText) {
+  const spinner2 = createSpinner(text4);
+  spinner2.start();
   try {
     const result = await fn();
-    spinner.succeed(successText || text3);
+    spinner2.succeed(successText || text4);
     return result;
   } catch (err) {
-    spinner.fail(text3);
+    spinner2.fail(text4);
     throw err;
   }
 }
@@ -575,30 +871,133 @@ function initGit(cwd) {
   }
 }
 
+// src/utils/register-app.ts
+import fs3 from "fs-extra";
+import path3 from "path";
+import os from "os";
+import * as p9 from "@clack/prompts";
+import chalk2 from "chalk";
+var CREDENTIALS_PATH = path3.join(os.homedir(), ".githat", "credentials.json");
+function readToken() {
+  if (!fs3.existsSync(CREDENTIALS_PATH)) {
+    return null;
+  }
+  try {
+    const creds = fs3.readJsonSync(CREDENTIALS_PATH);
+    return creds.token || null;
+  } catch {
+    return null;
+  }
+}
+async function registerApp(appName, projectRoot) {
+  const token = readToken();
+  if (!token) {
+    p9.log.warn(
+      chalk2.yellow(
+        `GitHat credentials not found at ${CREDENTIALS_PATH}.
+  Run ${chalk2.cyan("githat login")} then re-run scaffolding, or paste your publishable key
+  from ${chalk2.cyan("https://githat.io/dashboard/apps")} into .env.local manually.`
+      )
+    );
+    return null;
+  }
+  p9.log.step("Registering app on GitHat...");
+  let registeredApp;
+  try {
+    const response = await fetch(`${DEFAULT_API_URL}/apps`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`
+      },
+      body: JSON.stringify({
+        name: appName,
+        redirect_uris: ["http://localhost:3000/callback"]
+      })
+    });
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      throw new Error(`HTTP ${response.status}: ${body}`);
+    }
+    registeredApp = await response.json();
+  } catch (err) {
+    p9.log.warn(
+      chalk2.yellow(
+        `Could not register app on GitHat: ${err.message}
+  The scaffold was written successfully. Once the API is available,
+  register manually at ${chalk2.cyan("https://githat.io/dashboard/apps")} and paste the
+  publishable key into ${chalk2.cyan(".env.local")}.`
+      )
+    );
+    return null;
+  }
+  const publishableKey = registeredApp.publishable_key;
+  const envLocalPath = path3.join(projectRoot, ".env.local");
+  try {
+    let envContent = fs3.existsSync(envLocalPath) ? fs3.readFileSync(envLocalPath, "utf-8") : "";
+    const keyLine = `NEXT_PUBLIC_GITHAT_PUBLISHABLE_KEY=${publishableKey}`;
+    if (envContent.includes("NEXT_PUBLIC_GITHAT_PUBLISHABLE_KEY=")) {
+      envContent = envContent.replace(
+        /NEXT_PUBLIC_GITHAT_PUBLISHABLE_KEY=.*/,
+        keyLine
+      );
+    } else {
+      envContent += (envContent.endsWith("\n") || envContent === "" ? "" : "\n") + keyLine + "\n";
+    }
+    fs3.ensureDirSync(path3.dirname(envLocalPath));
+    fs3.writeFileSync(envLocalPath, envContent, "utf-8");
+  } catch (err) {
+    p9.log.warn(chalk2.yellow(`Registered app but could not write .env.local: ${err.message}`));
+  }
+  p9.log.success(chalk2.green(`Registered "${appName}" on GitHat. Publishable key written to .env.local.`));
+  return publishableKey;
+}
+
 // src/scaffold/index.ts
 async function scaffold(context, options) {
-  const root = path3.resolve(process.cwd(), context.projectName);
-  if (fs3.existsSync(root)) {
-    p7.cancel(`Directory "${context.projectName}" already exists.`);
+  const root = path4.resolve(process.cwd(), context.projectName);
+  if (fs4.existsSync(root)) {
+    p10.cancel(`Directory "${context.projectName}" already exists.`);
     process.exit(1);
   }
+  const isFullstack = context.projectType === "fullstack";
   await withSpinner("Creating project structure...", async () => {
-    fs3.ensureDirSync(root);
+    fs4.ensureDirSync(root);
     const templatesRoot = getTemplatesRoot();
-    const frameworkDir = path3.join(templatesRoot, context.framework);
-    if (!fs3.existsSync(frameworkDir)) {
-      throw new Error(`Templates not found at ${frameworkDir}. This is a bug \u2014 please report it.`);
-    }
-    renderTemplateDirectory(frameworkDir, root, context);
-    const baseDir = path3.join(templatesRoot, "base");
-    if (fs3.existsSync(baseDir)) {
-      renderTemplateDirectory(baseDir, root, context);
+    if (isFullstack) {
+      scaffoldFullstack(templatesRoot, root, context);
+    } else {
+      const frameworkDir = path4.join(templatesRoot, context.framework);
+      if (!fs4.existsSync(frameworkDir)) {
+        throw new Error(`Templates not found at ${frameworkDir}. This is a bug \u2014 please report it.`);
+      }
+      renderTemplateDirectory(frameworkDir, root, context);
+      const baseDir = path4.join(templatesRoot, "base");
+      if (fs4.existsSync(baseDir)) {
+        renderTemplateDirectory(baseDir, root, context);
+      }
     }
   }, "Project structure created");
-  await withSpinner("Generating package.json...", async () => {
-    const pkg = buildPackageJson(context);
-    writeJson(root, "package.json", pkg);
-  }, "package.json generated");
+  if (!isFullstack) {
+    await withSpinner("Generating package.json...", async () => {
+      const pkg = buildPackageJson(context);
+      writeJson(root, "package.json", pkg);
+    }, "package.json generated");
+  }
+  const NEXT_LIKE3 = /* @__PURE__ */ new Set([
+    "nextjs",
+    "plain",
+    "saas",
+    "marketplace",
+    "agent",
+    "content",
+    "dashboard",
+    "portfolio",
+    "classroom"
+  ]);
+  if (!isFullstack && NEXT_LIKE3.has(context.framework)) {
+    await registerApp(context.projectName, root);
+  }
   if (options.initGit) {
     const gitSpinner = createSpinner("Initializing git repository...");
     gitSpinner.start();
@@ -619,38 +1018,686 @@ async function scaffold(context, options) {
         } catch (err) {
           const msg = err.message || "";
           if (msg.includes("TIMEOUT")) {
-            p7.log.warn(`Install timed out. Run ${chalk2.cyan(installCmd)} manually.`);
+            p10.log.warn(`Install timed out. Run ${chalk3.cyan(installCmd)} manually.`);
           } else {
-            p7.log.warn(`Could not auto-install. Run ${chalk2.cyan(installCmd)} manually.`);
+            p10.log.warn(`Could not auto-install. Run ${chalk3.cyan(installCmd)} manually.`);
           }
         }
       },
       "Dependencies installed"
     );
   }
-  p7.outro("Setup complete!");
-  displaySuccess(context.projectName, context.packageManager, context.framework);
+  p10.outro("Setup complete!");
+  displaySuccess(context.projectName, context.packageManager, context.framework, !!context.publishableKey, isFullstack);
+  if (!options.skipPrompts) {
+    const starPrompt = await p10.confirm({
+      message: "Star GitHat on GitHub? (helps us grow!)",
+      initialValue: false
+    });
+    if (!p10.isCancel(starPrompt) && starPrompt) {
+      try {
+        const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+        execSync3(`${cmd} "https://github.com/GitHat-IO/githat"`, { stdio: "ignore" });
+      } catch {
+        p10.log.info("Visit https://github.com/GitHat-IO/githat to star us!");
+      }
+    }
+  }
+}
+function scaffoldFullstack(templatesRoot, root, context) {
+  const fullstackDir = path4.join(templatesRoot, "fullstack");
+  const rootDir = path4.join(fullstackDir, "root");
+  if (fs4.existsSync(rootDir)) {
+    renderTemplateDirectory(rootDir, root, context);
+  }
+  const appsDir = path4.join(root, "apps");
+  fs4.ensureDirSync(appsDir);
+  const webDir = path4.join(appsDir, "web");
+  fs4.ensureDirSync(webDir);
+  const webTemplateDir = path4.join(fullstackDir, `apps-web-${context.framework}`);
+  if (fs4.existsSync(webTemplateDir)) {
+    renderTemplateDirectory(webTemplateDir, webDir, context);
+  } else {
+    throw new Error(`Web app templates not found at ${webTemplateDir}. This is a bug \u2014 please report it.`);
+  }
+  const apiDir = path4.join(appsDir, "api");
+  fs4.ensureDirSync(apiDir);
+  const backendFramework = context.backendFramework || "hono";
+  const apiTemplateDir = path4.join(fullstackDir, `apps-api-${backendFramework}`);
+  if (fs4.existsSync(apiTemplateDir)) {
+    renderTemplateDirectory(apiTemplateDir, apiDir, context);
+  } else {
+    throw new Error(`API templates not found at ${apiTemplateDir}. This is a bug \u2014 please report it.`);
+  }
+  const packagesDir = path4.join(root, "packages");
+  fs4.ensureDirSync(packagesDir);
+  fs4.writeFileSync(path4.join(packagesDir, ".gitkeep"), "");
+}
+
+// src/commands/skills/index.ts
+import { Command as Command6 } from "commander";
+import chalk9 from "chalk";
+
+// src/commands/skills/search.ts
+import { Command } from "commander";
+import chalk4 from "chalk";
+
+// src/commands/skills/api.ts
+async function fetchApi(endpoint, options = {}) {
+  const url = `${DEFAULT_API_URL}${endpoint}`;
+  const response = await fetch(url, {
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ error: response.statusText }));
+    throw new Error(error.error || `API error: ${response.status}`);
+  }
+  return response.json();
+}
+async function searchSkills(query, type) {
+  const params = new URLSearchParams();
+  if (type) params.set("type", type);
+  const url = `/skills?${params.toString()}`;
+  const result = await fetchApi(url);
+  const q = query.toLowerCase();
+  return {
+    skills: result.skills.filter(
+      (s) => s.name.toLowerCase().includes(q) || s.description.toLowerCase().includes(q) || s.keywords.some((k) => k.toLowerCase().includes(q))
+    )
+  };
+}
+async function listSkills(options) {
+  const params = new URLSearchParams();
+  if (options.type) params.set("type", options.type);
+  if (options.limit) params.set("limit", options.limit.toString());
+  if (options.cursor) params.set("cursor", options.cursor);
+  return fetchApi(`/skills?${params.toString()}`);
+}
+async function getSkill(slug) {
+  return fetchApi(`/skills/${slug}`);
+}
+async function getDownloadUrl(slug, version) {
+  const params = version ? `?version=${version}` : "";
+  return fetchApi(`/skills/${slug}/download${params}`);
+}
+
+// src/commands/skills/search.ts
+function formatSkill(skill) {
+  const typeColors = {
+    template: chalk4.blue,
+    integration: chalk4.green,
+    ui: chalk4.magenta,
+    ai: chalk4.yellow,
+    workflow: chalk4.cyan
+  };
+  const typeColor = typeColors[skill.type] || chalk4.white;
+  return [
+    `${chalk4.bold(skill.name)} ${chalk4.dim(`@${skill.latestVersion}`)}`,
+    `  ${skill.description}`,
+    `  ${typeColor(skill.type)} \xB7 \u2B07 ${skill.downloads} \xB7 \u2B50 ${skill.stars} \xB7 by ${skill.authorName}`,
+    `  ${chalk4.dim(`githat skills install ${skill.slug}`)}`
+  ].join("\n");
+}
+var searchCommand = new Command("search").description("Search skills by keyword").argument("<query>", "Search query").option("-t, --type <type>", "Filter by type (template, integration, ui, ai, workflow)").action(async (query, options) => {
+  try {
+    console.log(chalk4.dim(`
+Searching for "${query}"...
+`));
+    const result = await searchSkills(query, options.type);
+    if (result.skills.length === 0) {
+      console.log(chalk4.yellow("No skills found matching your query."));
+      console.log(chalk4.dim("\nTry a different search term or browse all skills:"));
+      console.log(chalk4.dim("  githat skills list"));
+      return;
+    }
+    console.log(chalk4.cyan(`Found ${result.skills.length} skill(s):
+`));
+    for (const skill of result.skills) {
+      console.log(formatSkill(skill));
+      console.log("");
+    }
+  } catch (err) {
+    console.error(chalk4.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+});
+
+// src/commands/skills/list.ts
+import { Command as Command2 } from "commander";
+import chalk5 from "chalk";
+function formatSkillCompact(skill) {
+  const typeColors = {
+    template: chalk5.blue,
+    integration: chalk5.green,
+    ui: chalk5.magenta,
+    ai: chalk5.yellow,
+    workflow: chalk5.cyan
+  };
+  const typeColor = typeColors[skill.type] || chalk5.white;
+  const name = chalk5.bold(skill.name.padEnd(25));
+  const type = typeColor(skill.type.padEnd(12));
+  const stats = `\u2B07 ${String(skill.downloads).padStart(5)} \u2B50 ${String(skill.stars).padStart(4)}`;
+  const desc = skill.description.length > 40 ? skill.description.substring(0, 37) + "..." : skill.description;
+  return `${name} ${type} ${stats}  ${chalk5.dim(desc)}`;
+}
+var listCommand = new Command2("list").description("List available skills").option("-t, --type <type>", "Filter by type (template, integration, ui, ai, workflow)").option("-l, --limit <n>", "Number of results (default: 25)", "25").action(async (options) => {
+  try {
+    const limit = parseInt(options.limit, 10);
+    console.log(chalk5.dim("\nFetching skills...\n"));
+    const result = await listSkills({ type: options.type, limit });
+    if (result.skills.length === 0) {
+      console.log(chalk5.yellow("No skills found."));
+      if (options.type) {
+        console.log(chalk5.dim(`
+Try without the type filter:`));
+        console.log(chalk5.dim("  githat skills list"));
+      }
+      return;
+    }
+    const header = `${"NAME".padEnd(25)} ${"TYPE".padEnd(12)} ${"DOWNLOADS".padStart(10)}  DESCRIPTION`;
+    console.log(chalk5.dim(header));
+    console.log(chalk5.dim("\u2500".repeat(80)));
+    for (const skill of result.skills) {
+      console.log(formatSkillCompact(skill));
+    }
+    console.log(chalk5.dim("\u2500".repeat(80)));
+    console.log(chalk5.dim(`Showing ${result.skills.length} skill(s)`));
+    if (result.nextCursor) {
+      console.log(chalk5.dim("\nMore results available. Use --limit to see more."));
+    }
+    console.log(chalk5.dim("\nTo install: githat skills install <name>"));
+  } catch (err) {
+    console.error(chalk5.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+});
+
+// src/commands/skills/install.ts
+import { Command as Command3 } from "commander";
+import chalk6 from "chalk";
+import * as fs5 from "fs";
+import * as path5 from "path";
+import { pipeline } from "stream/promises";
+import { createWriteStream, mkdirSync } from "fs";
+import { Extract } from "unzipper";
+async function downloadAndExtract(url, destDir) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Download failed: ${response.statusText}`);
+  }
+  const tempZip = path5.join(destDir, ".skill-download.zip");
+  const fileStream = createWriteStream(tempZip);
+  await pipeline(response.body, fileStream);
+  await new Promise((resolve4, reject) => {
+    fs5.createReadStream(tempZip).pipe(Extract({ path: destDir })).on("close", resolve4).on("error", reject);
+  });
+  fs5.unlinkSync(tempZip);
+}
+function updateGithatLock(projectDir, skill) {
+  const lockPath = path5.join(projectDir, "githat.lock");
+  let lock = {};
+  if (fs5.existsSync(lockPath)) {
+    try {
+      lock = JSON.parse(fs5.readFileSync(lockPath, "utf-8"));
+    } catch {
+    }
+  }
+  lock[skill.slug] = {
+    version: skill.version,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  fs5.writeFileSync(lockPath, JSON.stringify(lock, null, 2));
+}
+function updateEnvExample(projectDir, manifest) {
+  if (!manifest.requires?.env?.length) return;
+  const envPath = path5.join(projectDir, ".env.local");
+  const envExamplePath = path5.join(projectDir, ".env.example");
+  let envContent = "";
+  if (fs5.existsSync(envPath)) {
+    envContent = fs5.readFileSync(envPath, "utf-8");
+  } else if (fs5.existsSync(envExamplePath)) {
+    envContent = fs5.readFileSync(envExamplePath, "utf-8");
+  }
+  const existingVars = new Set(
+    envContent.split("\n").filter((line) => line.includes("=")).map((line) => line.split("=")[0].trim())
+  );
+  const newVars = [];
+  for (const envVar of manifest.requires.env) {
+    if (!existingVars.has(envVar)) {
+      newVars.push(`${envVar}=`);
+    }
+  }
+  if (newVars.length > 0) {
+    const addition = `
+# Added by skill install
+${newVars.join("\n")}
+`;
+    if (fs5.existsSync(envPath)) {
+      fs5.appendFileSync(envPath, addition);
+    } else {
+      fs5.writeFileSync(envPath, `# Environment variables
+${newVars.join("\n")}
+`);
+    }
+  }
+}
+var installCommand = new Command3("install").description("Install a skill to your project").argument("<slug>", "Skill slug (e.g., stripe-billing)").option("-v, --version <version>", "Specific version to install").option("-d, --dir <dir>", "Project directory (default: current directory)").action(async (slug, options) => {
+  try {
+    const projectDir = options.dir ? path5.resolve(options.dir) : process.cwd();
+    const packageJsonPath = path5.join(projectDir, "package.json");
+    if (!fs5.existsSync(packageJsonPath)) {
+      console.error(chalk6.red("Error: No package.json found. Are you in a project directory?"));
+      process.exit(1);
+    }
+    console.log(chalk6.dim(`
+Fetching skill info for "${slug}"...
+`));
+    const skill = await getSkill(slug);
+    console.log(chalk6.cyan(`\u{1F4E6} ${skill.name}`));
+    console.log(chalk6.dim(`   ${skill.description}`));
+    console.log(chalk6.dim(`   Type: ${skill.type} \xB7 Author: ${skill.authorName}
+`));
+    const download = await getDownloadUrl(slug, options.version);
+    const version = download.version.version;
+    console.log(chalk6.dim(`Downloading ${skill.name}@${version}...`));
+    const skillDir = path5.join(projectDir, "githat", "skills", slug);
+    mkdirSync(skillDir, { recursive: true });
+    await downloadAndExtract(download.downloadUrl, skillDir);
+    console.log(chalk6.green(`\u2713 Downloaded to ${path5.relative(projectDir, skillDir)}`));
+    const manifestPath = path5.join(skillDir, "githat-skill.json");
+    if (fs5.existsSync(manifestPath)) {
+      const manifest = JSON.parse(fs5.readFileSync(manifestPath, "utf-8"));
+      updateEnvExample(projectDir, manifest);
+      if (manifest.requires?.env?.length) {
+        console.log(chalk6.yellow(`
+\u26A0 Required environment variables:`));
+        for (const envVar of manifest.requires.env) {
+          console.log(chalk6.dim(`   ${envVar}`));
+        }
+        console.log(chalk6.dim(`
+   Add these to your .env.local file`));
+      }
+      if (manifest.install?.dependencies) {
+        const deps = Object.entries(manifest.install.dependencies).map(([name, ver]) => `${name}@${ver}`).join(" ");
+        console.log(chalk6.yellow(`
+\u26A0 Install npm dependencies:`));
+        console.log(chalk6.dim(`   npm install ${deps}`));
+      }
+    }
+    updateGithatLock(projectDir, { slug, version });
+    console.log(chalk6.green(`
+\u2705 Successfully installed ${skill.name}@${version}
+`));
+    console.log(chalk6.dim("Next steps:"));
+    console.log(chalk6.dim(`  1. Check githat/skills/${slug}/README.md for usage`));
+    console.log(chalk6.dim("  2. Add required environment variables to .env.local"));
+    console.log(chalk6.dim("  3. Import and use the skill in your code"));
+  } catch (err) {
+    console.error(chalk6.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+});
+
+// src/commands/skills/installed.ts
+import { Command as Command4 } from "commander";
+import chalk7 from "chalk";
+import * as fs6 from "fs";
+import * as path6 from "path";
+var installedCommand = new Command4("installed").alias("ls").description("List installed skills in current project").option("-d, --dir <dir>", "Project directory (default: current directory)").action(async (options) => {
+  try {
+    const projectDir = options.dir ? path6.resolve(options.dir) : process.cwd();
+    const lockPath = path6.join(projectDir, "githat.lock");
+    if (!fs6.existsSync(lockPath)) {
+      console.log(chalk7.yellow("\nNo skills installed in this project."));
+      console.log(chalk7.dim("\nTo install a skill:"));
+      console.log(chalk7.dim("  githat skills install <slug>"));
+      return;
+    }
+    let lock;
+    try {
+      lock = JSON.parse(fs6.readFileSync(lockPath, "utf-8"));
+    } catch {
+      console.error(chalk7.red("Error: Invalid githat.lock file"));
+      process.exit(1);
+    }
+    const entries = Object.entries(lock);
+    if (entries.length === 0) {
+      console.log(chalk7.yellow("\nNo skills installed in this project."));
+      return;
+    }
+    console.log(chalk7.cyan(`
+\u{1F4E6} Installed skills (${entries.length}):
+`));
+    console.log(chalk7.dim(`${"SKILL".padEnd(30)} ${"VERSION".padEnd(12)} INSTALLED`));
+    console.log(chalk7.dim("\u2500".repeat(60)));
+    for (const [slug, entry] of entries) {
+      const date = new Date(entry.installedAt).toLocaleDateString();
+      console.log(`${chalk7.bold(slug.padEnd(30))} ${entry.version.padEnd(12)} ${chalk7.dim(date)}`);
+    }
+    console.log(chalk7.dim("\u2500".repeat(60)));
+    console.log(chalk7.dim("\nTo update a skill:"));
+    console.log(chalk7.dim("  githat skills install <slug> --version <new-version>"));
+  } catch (err) {
+    console.error(chalk7.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+});
+
+// src/commands/skills/init.ts
+import { Command as Command5 } from "commander";
+import chalk8 from "chalk";
+import * as fs7 from "fs";
+import * as path7 from "path";
+import * as p11 from "@clack/prompts";
+var SKILL_TYPES = ["template", "integration", "ui", "ai", "workflow"];
+function generateReadme(manifest) {
+  return `# ${manifest.name}
+
+${manifest.description}
+
+## Installation
+
+\`\`\`bash
+githat skills install ${manifest.name}
+\`\`\`
+
+## Requirements
+
+${manifest.requires.env.length > 0 ? `
+### Environment Variables
+
+${manifest.requires.env.map((e) => `- \`${e}\``).join("\n")}
+` : ""}
+${manifest.requires.tier ? `
+### Minimum Tier
+
+This skill requires **${manifest.requires.tier}** tier or higher.
+` : ""}
+
+## Usage
+
+\`\`\`typescript
+// Import from the installed skill
+import { /* exports */ } from './githat/skills/${manifest.name}';
+
+// Use the skill
+// ...
+\`\`\`
+
+## License
+
+${manifest.license}
+`;
 }
+function generateIndexFile(manifest) {
+  const typeExports = {
+    template: `// Template skill - provides project scaffolding
+export const templateName = '${manifest.name}';
+export const templateVersion = '${manifest.version}';
+
+// Add your template exports here
+`,
+    integration: `// Integration skill - connects to external services
+// Replace with your actual integration code
+
+export interface ${toPascalCase(manifest.name)}Config {
+  apiKey: string;
+  // Add configuration options
+}
+
+export function create${toPascalCase(manifest.name)}(config: ${toPascalCase(manifest.name)}Config) {
+  // Initialize your integration
+  return {
+    // Return your integration client/functions
+  };
+}
+`,
+    ui: `// UI skill - provides React components
+import React from 'react';
+
+export interface ${toPascalCase(manifest.name)}Props {
+  // Add component props
+}
+
+export function ${toPascalCase(manifest.name)}({ ...props }: ${toPascalCase(manifest.name)}Props) {
+  return (
+    <div>
+      {/* Your component */}
+    </div>
+  );
+}
+`,
+    ai: `// AI skill - MCP server / Claude tools
+export interface Tool {
+  name: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+}
+
+export const tools: Tool[] = [
+  {
+    name: '${manifest.name.replace(/-/g, "_")}',
+    description: '${manifest.description}',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        // Add input properties
+      },
+    },
+  },
+];
+
+export async function handleTool(name: string, input: Record<string, unknown>) {
+  // Handle tool invocations
+}
+`,
+    workflow: `// Workflow skill - automation recipes
+export interface WorkflowTrigger {
+  event: string;
+  condition?: string;
+}
+
+export interface WorkflowStep {
+  id: string;
+  run?: string;
+  action?: string;
+}
+
+export const triggers: WorkflowTrigger[] = [
+  { event: 'deploy.success' },
+];
+
+export const steps: WorkflowStep[] = [
+  { id: 'notify', run: 'echo "Workflow executed"' },
+];
+`
+  };
+  return typeExports[manifest.type];
+}
+function toPascalCase(str) {
+  return str.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+var initCommand = new Command5("init").description("Initialize a new skill package").argument("<name>", "Skill name (slug format: lowercase-with-hyphens)").option("-t, --type <type>", "Skill type (template, integration, ui, ai, workflow)").option("-d, --dir <dir>", "Parent directory (default: current directory)").action(async (name, options) => {
+  try {
+    if (!/^[a-z][a-z0-9-]{1,62}[a-z0-9]$/.test(name)) {
+      console.error(chalk8.red("Error: Name must be lowercase alphanumeric with hyphens (2-64 chars, start with letter)"));
+      process.exit(1);
+    }
+    const parentDir = options.dir ? path7.resolve(options.dir) : process.cwd();
+    const skillDir = path7.join(parentDir, name);
+    if (fs7.existsSync(skillDir)) {
+      console.error(chalk8.red(`Error: Directory "${name}" already exists`));
+      process.exit(1);
+    }
+    console.log(chalk8.cyan(`
+\u{1F4E6} Initializing skill: ${name}
+`));
+    let type;
+    if (options.type && SKILL_TYPES.includes(options.type)) {
+      type = options.type;
+    } else {
+      const result = await p11.select({
+        message: "What type of skill are you creating?",
+        options: [
+          { value: "integration", label: "Integration", hint: "Connect to external services (Stripe, SendGrid, etc.)" },
+          { value: "template", label: "Template", hint: "Full project scaffolding" },
+          { value: "ui", label: "UI Pack", hint: "Reusable React components" },
+          { value: "ai", label: "AI Skill", hint: "MCP server / Claude tools" },
+          { value: "workflow", label: "Workflow", hint: "Automation recipes" }
+        ]
+      });
+      if (p11.isCancel(result)) {
+        p11.cancel("Operation cancelled");
+        process.exit(0);
+      }
+      type = result;
+    }
+    const description = await p11.text({
+      message: "Short description:",
+      placeholder: `A ${type} skill for...`,
+      validate: (v) => v.length < 10 ? "Description must be at least 10 characters" : void 0
+    });
+    if (p11.isCancel(description)) {
+      p11.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    const manifest = {
+      name,
+      version: "1.0.0",
+      description,
+      type,
+      author: {
+        name: "Your Name",
+        email: "your@email.com"
+      },
+      license: "MIT",
+      requires: {
+        env: []
+      },
+      files: {
+        lib: "src/index.ts"
+      },
+      install: {
+        dependencies: {},
+        envExample: {}
+      },
+      keywords: [type]
+    };
+    fs7.mkdirSync(skillDir, { recursive: true });
+    fs7.mkdirSync(path7.join(skillDir, "src"), { recursive: true });
+    fs7.writeFileSync(
+      path7.join(skillDir, "githat-skill.json"),
+      JSON.stringify(manifest, null, 2)
+    );
+    fs7.writeFileSync(
+      path7.join(skillDir, "README.md"),
+      generateReadme(manifest)
+    );
+    fs7.writeFileSync(
+      path7.join(skillDir, "src", "index.ts"),
+      generateIndexFile(manifest)
+    );
+    fs7.writeFileSync(
+      path7.join(skillDir, ".gitignore"),
+      `node_modules/
+dist/
+.env
+.env.local
+*.log
+`
+    );
+    console.log(chalk8.green(`
+\u2705 Created skill at ${skillDir}
+`));
+    console.log(chalk8.dim("Files created:"));
+    console.log(chalk8.dim(`  githat-skill.json  - Skill manifest`));
+    console.log(chalk8.dim(`  README.md          - Documentation`));
+    console.log(chalk8.dim(`  src/index.ts       - Main entry point`));
+    console.log(chalk8.dim(`  .gitignore         - Git ignore rules`));
+    console.log(chalk8.dim("\nNext steps:"));
+    console.log(chalk8.dim(`  1. cd ${name}`));
+    console.log(chalk8.dim(`  2. Edit githat-skill.json with your details`));
+    console.log(chalk8.dim(`  3. Implement your skill in src/index.ts`));
+    console.log(chalk8.dim(`  4. Publish: githat skills publish .`));
+  } catch (err) {
+    console.error(chalk8.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+});
+
+// src/commands/skills/index.ts
+var skillsCommand = new Command6("skills").description("Manage GitHat skills marketplace").addCommand(searchCommand).addCommand(listCommand).addCommand(installCommand).addCommand(installedCommand).addCommand(initCommand);
+skillsCommand.action(() => {
+  console.log(chalk9.cyan("\n\u{1F4E6} GitHat Skills Marketplace\n"));
+  console.log("Commands:");
+  console.log("  search <query>     Search skills by keyword");
+  console.log("  list               List skills (filterable by type)");
+  console.log("  install <slug>     Install a skill to your project");
+  console.log("  installed          List installed skills");
+  console.log("  init <name>        Initialize a new skill package");
+  console.log("\nExamples:");
+  console.log("  githat skills search stripe");
+  console.log("  githat skills list --type=integration");
+  console.log("  githat skills install stripe-billing");
+  console.log("  githat skills init my-skill --type=integration");
+  console.log("");
+});
 
 // src/cli.ts
-var program = new Command();
-program.name("create-githat-app").description("Scaffold enterprise-grade apps with GitHat identity").version(VERSION).argument("[project-name]", "Name of the project directory").option("--key <key>", "GitHat publishable key (pk_live_...)").option("--ts", "Use TypeScript (default)").option("--js", "Use JavaScript").action(async (projectName, opts) => {
+var program = new Command7();
+program.name("githat").description("GitHat CLI - Scaffold apps and manage skills").version(VERSION);
+program.command("create [project-name]", { isDefault: true }).description("Scaffold a new GitHat app").option("--key <key>", "CI only: bake key into .env.local. Default flow is paste into .env.local after scaffold.").option("--ts", "Use TypeScript (default)").option("--js", "Use JavaScript").option("--plain", "Smallest scaffold: auth + a homepage. No dashboard.").option("--saas", "B2B starter: orgs, teams, RBAC, subscription billing.").option("--marketplace", "Multi-vendor commerce: anonymous-first browsing, Sebastn Connect.").option("--agent", "Web4 wallet-bound autonomous agent + MCP server registration.").option("--content", "Paywalled posts, newsletter, one-time purchases via Sebastn.").option("--dashboard", "Admin UI over your existing database, auth-gated.").option("--portfolio", "Personal portfolio: public projects, auth-gated editor.").option("--classroom", "Live student presentations with real-time audience feedback.").option("--fullstack", "Create fullstack project (Turborepo)").option("--backend <framework>", "Backend framework (hono, express, fastify)").option("-y, --yes", "Skip prompts and use defaults").action(async (projectName, opts) => {
   try {
     displayBanner();
+    if (!opts.yes && !opts.key) {
+      p12.note(
+        [
+          chalk10.bold("How the GitHat key flow works:"),
+          "",
+          `  ${chalk10.cyan("1.")} We'll scaffold your project with a placeholder`,
+          `     in ${chalk10.bold(".env.local")} (gitignored \u2014 safe to keep secrets here)`,
+          "",
+          `  ${chalk10.cyan("2.")} You open ${chalk10.cyan("https://githat.io/dashboard/apps")}`,
+          `     and copy your publishable key`,
+          "",
+          `  ${chalk10.cyan("3.")} You paste it into ${chalk10.bold(".env.local")} and run`,
+          `     ${chalk10.dim("npm run dev")}`,
+          "",
+          chalk10.dim("Why not pass the key on the command line? Shell"),
+          chalk10.dim("history is forever. .env.local is more secure.")
+        ].join("\n"),
+        "First time with GitHat?"
+      );
+    }
     const typescript = opts.js ? false : opts.ts ? true : void 0;
+    if (opts.yes && !projectName) {
+      p12.cancel(chalk10.red("Project name is required when using --yes flag"));
+      process.exit(1);
+    }
+    const template = opts.marketplace ? "marketplace" : opts.classroom ? "classroom" : opts.portfolio ? "portfolio" : opts.agent ? "agent" : opts.saas ? "saas" : opts.content ? "content" : opts.dashboard ? "dashboard" : opts.plain ? "plain" : void 0;
     const answers = await runPrompts({
       initialName: projectName,
       publishableKey: opts.key,
-      typescript
+      typescript,
+      yes: opts.yes,
+      template,
+      fullstack: opts.fullstack,
+      backendFramework: opts.backend
     });
     const context = answersToContext(answers);
     await scaffold(context, {
       installDeps: answers.installDeps,
-      initGit: answers.initGit
+      initGit: answers.initGit,
+      skipPrompts: opts.yes
     });
   } catch (err) {
-    p8.cancel(chalk3.red(err.message || "Something went wrong."));
+    p12.cancel(chalk10.red(err.message || "Something went wrong."));
     process.exit(1);
   }
 });
+program.addCommand(skillsCommand);
 program.parse();