create-githat-app 1.0.0 → 1.0.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 p9 from "@clack/prompts";
+import chalk9 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.0.0";
+var VERSION = "0.5.1";
 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,7 @@ var DEPS = {
       next: "^16.0.0",
       react: "^19.0.0",
       "react-dom": "^19.0.0",
-      "@githat/nextjs": "^0.2.0"
+      "@githat/nextjs": "^0.5.0"
     },
     devDependencies: {
       typescript: "^5.9.0",
@@ -35,7 +35,7 @@ var DEPS = {
       react: "^19.0.0",
       "react-dom": "^19.0.0",
       "react-router-dom": "^7.0.0",
-      "@githat/nextjs": "^0.2.0"
+      "@githat/nextjs": "^0.5.0"
     },
     devDependencies: {
       vite: "^7.0.0",
@@ -77,35 +77,76 @@ var DEPS = {
 };
 
 // src/utils/ascii.ts
-var githatGradient = gradient([...BRAND_COLORS]);
+var brand = gradient([...BRAND_COLORS]);
+var violet = chalk.hex("#a78bfa");
+var dim = chalk.dim;
+function visibleLength(str) {
+  return str.replace(/\u001b\[.*?m/g, "").length;
+}
+function getBoxWidth() {
+  const termWidth = process.stdout.columns || 80;
+  return Math.min(70, Math.max(40, termWidth - 6));
+}
+function drawBox(lines) {
+  const W = getBoxWidth();
+  const hr = "\u2500".repeat(W);
+  console.log(dim(`  \u256D${hr}\u256E`));
+  console.log(dim(`  \u2502${" ".repeat(W)}\u2502`));
+  for (const line of lines) {
+    const pad = W - 2 - visibleLength(line);
+    console.log(dim("  \u2502") + `  ${line}${" ".repeat(Math.max(0, pad))}` + dim("\u2502"));
+  }
+  console.log(dim(`  \u2502${" ".repeat(W)}\u2502`));
+  console.log(dim(`  \u2570${hr}\u256F`));
+}
 function displayBanner() {
   const ascii = figlet.textSync("GitHat", {
-    font: "Slant",
+    font: "ANSI Shadow",
     horizontalLayout: "default"
   });
   console.log("");
-  console.log(githatGradient(ascii));
-  console.log(chalk.dim("  Identity for humans, agents, and MCP servers"));
-  console.log(chalk.dim(`  v${VERSION} | githat.io`));
+  console.log(brand(ascii));
+  drawBox([
+    `${violet("\u2726")}  Create a new GitHat app`,
+    "",
+    dim("The developer platform"),
+    dim("for humans, agents & MCP servers"),
+    "",
+    dim(`v${VERSION}  \xB7  githat.io`)
+  ]);
   console.log("");
 }
-function displaySuccess(projectName, packageManager, framework) {
-  const devCmd = packageManager === "npm" ? "npm run dev" : `${packageManager} dev`;
-  const port = framework === "react-vite" ? "5173" : "3000";
-  console.log("");
-  console.log(githatGradient("  \u2726 Your GitHat app is ready!"));
+function sectionHeader(title) {
+  const W = getBoxWidth();
+  const lineLen = Math.max(1, W - 6 - title.length);
   console.log("");
-  console.log(`  ${chalk.cyan("cd")} ${projectName}`);
-  console.log(`  ${chalk.cyan(devCmd)}`);
+  console.log(dim(`  \u2500\u2500\u2500 ${title} ${"\u2500".repeat(lineLen)}`));
   console.log("");
-  console.log(chalk.dim(`  \u2192 http://localhost:${port}`));
-  console.log("");
-  console.log(chalk.dim("  Routes:"));
-  console.log(chalk.dim("  /sign-in       Sign in"));
-  console.log(chalk.dim("  /sign-up       Create account"));
-  console.log(chalk.dim("  /dashboard     Protected dashboard"));
+}
+function displaySuccess(projectName, packageManager, framework, hasPublishableKey = true) {
+  const devCmd = packageManager === "npm" ? "npm run dev" : `${packageManager} dev`;
+  const port = framework === "react-vite" ? "5173" : "3000";
   console.log("");
-  console.log(chalk.dim("  Docs: https://githat.io/docs/sdk"));
+  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 ? [] : [
+      chalk.yellow("No key configured \u2014 auth works on localhost."),
+      `For production: ${violet("githat.io/dashboard/apps")}`,
+      ""
+    ],
+    dim("Docs \u2192 https://githat.io/docs/sdk")
+  ]);
   console.log("");
 }
 
@@ -132,15 +173,6 @@ function validatePublishableKey(key) {
   }
   return void 0;
 }
-function validateApiUrl(url) {
-  if (!url) return "API URL is required";
-  try {
-    new URL(url);
-    return void 0;
-  } catch {
-    return "Must be a valid URL";
-  }
-}
 
 // src/prompts/project.ts
 async function promptProject(initialName) {
@@ -153,14 +185,9 @@ async function promptProject(initialName) {
         validate: validateProjectName
       }),
       businessName: () => p.text({
-        message: "Business or app display name",
+        message: "Display name",
         placeholder: "Acme Corp",
         validate: (v) => !v ? "Display name is required" : void 0
-      }),
-      description: () => p.text({
-        message: "One-line description",
-        placeholder: "A platform for managing identity across humans and AI",
-        initialValue: ""
       })
     },
     {
@@ -173,7 +200,7 @@ async function promptProject(initialName) {
   return {
     projectName: answers.projectName,
     businessName: answers.businessName,
-    description: answers.description || `${answers.businessName} \u2014 Built with GitHat identity`
+    description: `${answers.businessName} \u2014 Built with GitHat`
   };
 }
 
@@ -181,7 +208,6 @@ async function promptProject(initialName) {
 import * as p2 from "@clack/prompts";
 
 // src/utils/package-manager.ts
-import { execSync } from "child_process";
 function detectPackageManager() {
   const userAgent = process.env.npm_config_user_agent || "";
   if (userAgent.startsWith("pnpm")) return "pnpm";
@@ -189,14 +215,6 @@ function detectPackageManager() {
   if (userAgent.startsWith("bun")) return "bun";
   return "npm";
 }
-function isAvailable(pm) {
-  try {
-    execSync(`${pm} --version`, { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
 function getInstallCommand(pm) {
   const cmds = {
     npm: "npm install",
@@ -209,14 +227,14 @@ function getInstallCommand(pm) {
 
 // src/prompts/framework.ts
 async function promptFramework(typescriptOverride) {
-  const detected = detectPackageManager();
+  const packageManager = detectPackageManager();
   const answers = await p2.group(
     {
       framework: () => p2.select({
         message: "Framework",
         options: [
-          { value: "nextjs", label: "Next.js 16", hint: "App Router, SSR, middleware auth" },
-          { value: "react-vite", label: "React 19 + Vite 7", hint: "SPA, client-side routing" }
+          { 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" }
         ]
       }),
       typescript: () => typescriptOverride !== void 0 ? Promise.resolve(typescriptOverride) : p2.select({
@@ -225,15 +243,6 @@ async function promptFramework(typescriptOverride) {
           { value: true, label: "TypeScript", hint: "recommended" },
           { value: false, label: "JavaScript" }
         ]
-      }),
-      packageManager: () => p2.select({
-        message: "Package manager",
-        initialValue: detected,
-        options: ["npm", "pnpm", "yarn", "bun"].filter((pm) => pm === detected || isAvailable(pm)).map((pm) => ({
-          value: pm,
-          label: pm,
-          hint: pm === detected ? "detected" : void 0
-        }))
       })
     },
     {
@@ -246,51 +255,85 @@ async function promptFramework(typescriptOverride) {
   return {
     framework: answers.framework,
     typescript: answers.typescript,
-    packageManager: answers.packageManager
+    packageManager
   };
 }
 
 // src/prompts/githat.ts
+import { execSync } from "child_process";
 import * as p3 from "@clack/prompts";
+function openBrowser(url) {
+  try {
+    const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+    execSync(`${cmd} "${url}"`, { stdio: "ignore" });
+  } catch {
+  }
+}
 async function promptGitHat(existingKey) {
-  const answers = await p3.group(
-    {
-      publishableKey: () => existingKey ? Promise.resolve(existingKey) : p3.text({
-        message: "GitHat publishable key",
+  let publishableKey = existingKey || "";
+  if (!publishableKey) {
+    const connectChoice = await p3.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" }
+      ]
+    });
+    if (p3.isCancel(connectChoice)) {
+      p3.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);
+      }
+      publishableKey = pastedKey || "";
+    } else if (connectChoice === "paste") {
+      const pastedKey = await p3.text({
+        message: "Publishable key",
         placeholder: `pk_live_... (get one at ${DASHBOARD_URL})`,
-        initialValue: "",
         validate: validatePublishableKey
-      }),
-      apiUrl: () => p3.text({
-        message: "GitHat API URL",
-        placeholder: DEFAULT_API_URL,
-        initialValue: DEFAULT_API_URL,
-        validate: validateApiUrl
-      }),
-      authFeatures: () => p3.multiselect({
-        message: "Auth features",
-        options: [
-          { value: "forgot-password", label: "Forgot password / Reset password", hint: "recommended" },
-          { value: "email-verification", label: "Email verification", hint: "recommended" },
-          { value: "org-management", label: "Organization management", hint: "teams, invites, roles" },
-          { value: "mcp-servers", label: "MCP server registration", hint: "tool verification" },
-          { value: "ai-agents", label: "AI agent wallet auth", hint: "Ethereum signatures" }
-        ],
-        initialValues: ["forgot-password", "email-verification"],
-        required: false
-      })
-    },
-    {
-      onCancel: () => {
+      });
+      if (p3.isCancel(pastedKey)) {
         p3.cancel("Setup cancelled.");
         process.exit(0);
       }
+      publishableKey = pastedKey || "";
+    } else if (connectChoice === "skip") {
+      p3.log.info("Auth works on localhost without a key (CORS bypass for development).");
+      p3.log.info("Sign up at githat.io \u2014 a publishable key is auto-created for you.");
     }
-  );
+  }
+  const authFeatures = await p3.multiselect({
+    message: "Auth features",
+    options: [
+      { value: "forgot-password", label: "Forgot password", hint: "reset via email" },
+      { value: "email-verification", label: "Email verification" },
+      { value: "org-management", label: "Organizations", hint: "teams & roles" },
+      { value: "mcp-servers", label: "MCP servers", hint: "Model Context Protocol" },
+      { value: "ai-agents", label: "AI agents", hint: "wallet-based identity" }
+    ],
+    initialValues: ["forgot-password"],
+    required: false
+  });
+  if (p3.isCancel(authFeatures)) {
+    p3.cancel("Setup cancelled.");
+    process.exit(0);
+  }
   return {
-    publishableKey: answers.publishableKey || "",
-    apiUrl: answers.apiUrl || DEFAULT_API_URL,
-    authFeatures: answers.authFeatures || []
+    publishableKey,
+    apiUrl: DEFAULT_API_URL,
+    authFeatures: authFeatures || []
   };
 }
 
@@ -302,22 +345,15 @@ async function promptFeatures() {
       databaseChoice: () => p4.select({
         message: "Database",
         options: [
-          { value: "none", label: "None \u2014 API only", hint: "use GitHat backend directly" },
+          { value: "none", label: "None", hint: "use GitHat backend directly" },
           { value: "prisma-postgres", label: "Prisma + PostgreSQL" },
           { value: "prisma-mysql", label: "Prisma + MySQL" },
           { value: "drizzle-postgres", label: "Drizzle + PostgreSQL" },
           { value: "drizzle-sqlite", label: "Drizzle + SQLite" }
         ]
       }),
-      useTailwind: () => p4.confirm({ message: "Include Tailwind CSS?", initialValue: true }),
-      includeDashboard: () => p4.confirm({
-        message: "Include full dashboard?",
-        initialValue: true
-      }),
-      includeGithatFolder: () => p4.confirm({
-        message: "Include githat/ platform folder?",
-        initialValue: true
-      })
+      useTailwind: () => p4.confirm({ message: "Tailwind CSS?", initialValue: true }),
+      includeDashboard: () => p4.confirm({ message: "Include dashboard?", initialValue: true })
     },
     {
       onCancel: () => {
@@ -330,38 +366,39 @@ async function promptFeatures() {
     databaseChoice: answers.databaseChoice,
     useTailwind: answers.useTailwind,
     includeDashboard: answers.includeDashboard,
-    includeGithatFolder: answers.includeGithatFolder
+    includeGithatFolder: true
   };
 }
 
 // src/prompts/finalize.ts
 import * as p5 from "@clack/prompts";
 async function promptFinalize() {
-  const answers = await p5.group(
-    {
-      initGit: () => p5.confirm({ message: "Initialize git repository?", initialValue: true }),
-      installDeps: () => p5.confirm({ message: "Install dependencies now?", initialValue: true })
-    },
-    {
-      onCancel: () => {
-        p5.cancel("Setup cancelled.");
-        process.exit(0);
-      }
-    }
-  );
+  const installDeps = await p5.confirm({
+    message: "Install dependencies?",
+    initialValue: true
+  });
+  if (p5.isCancel(installDeps)) {
+    p5.cancel("Setup cancelled.");
+    process.exit(0);
+  }
   return {
-    initGit: answers.initGit,
-    installDeps: answers.installDeps
+    initGit: true,
+    installDeps
   };
 }
 
 // src/prompts/index.ts
 async function runPrompts(args) {
   p6.intro("Let\u2019s set up your GitHat app");
+  sectionHeader("Project");
   const project = await promptProject(args.initialName);
+  sectionHeader("Stack");
   const framework = await promptFramework(args.typescript);
+  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 };
 }
@@ -404,7 +441,7 @@ import path from "path";
 import { fileURLToPath } from "url";
 var __filename2 = fileURLToPath(import.meta.url);
 var __dirname2 = path.dirname(__filename2);
-var TEMPLATES_ROOT = path.resolve(__dirname2, "..", "..", "templates");
+var TEMPLATES_ROOT = path.resolve(__dirname2, "..", "templates");
 Handlebars.registerHelper("ifEquals", function(a, b, options) {
   return a === b ? options.fn(this) : options.inverse(this);
 });
@@ -511,18 +548,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);
+async function withSpinner(text4, fn, successText) {
+  const spinner = createSpinner(text4);
   spinner.start();
   try {
     const result = await fn();
-    spinner.succeed(successText || text3);
+    spinner.succeed(successText || text4);
     return result;
   } catch (err) {
-    spinner.fail(text3);
+    spinner.fail(text4);
     throw err;
   }
 }
@@ -554,9 +591,10 @@ async function scaffold(context, options) {
     fs3.ensureDirSync(root);
     const templatesRoot = getTemplatesRoot();
     const frameworkDir = path3.join(templatesRoot, context.framework);
-    if (fs3.existsSync(frameworkDir)) {
-      renderTemplateDirectory(frameworkDir, root, context);
+    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);
@@ -596,12 +634,598 @@ async function scaffold(context, options) {
     );
   }
   p7.outro("Setup complete!");
-  displaySuccess(context.projectName, context.packageManager, context.framework);
+  displaySuccess(context.projectName, context.packageManager, context.framework, !!context.publishableKey);
+  const starPrompt = await p7.confirm({
+    message: "Star GitHat on GitHub? (helps us grow!)",
+    initialValue: false
+  });
+  if (!p7.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 {
+      p7.log.info("Visit https://github.com/GitHat-IO/githat to star us!");
+    }
+  }
+}
+
+// src/commands/skills/index.ts
+import { Command as Command6 } from "commander";
+import chalk8 from "chalk";
+
+// src/commands/skills/search.ts
+import { Command } from "commander";
+import chalk3 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: chalk3.blue,
+    integration: chalk3.green,
+    ui: chalk3.magenta,
+    ai: chalk3.yellow,
+    workflow: chalk3.cyan
+  };
+  const typeColor = typeColors[skill.type] || chalk3.white;
+  return [
+    `${chalk3.bold(skill.name)} ${chalk3.dim(`@${skill.latestVersion}`)}`,
+    `  ${skill.description}`,
+    `  ${typeColor(skill.type)} \xB7 \u2B07 ${skill.downloads} \xB7 \u2B50 ${skill.stars} \xB7 by ${skill.authorName}`,
+    `  ${chalk3.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(chalk3.dim(`
+Searching for "${query}"...
+`));
+    const result = await searchSkills(query, options.type);
+    if (result.skills.length === 0) {
+      console.log(chalk3.yellow("No skills found matching your query."));
+      console.log(chalk3.dim("\nTry a different search term or browse all skills:"));
+      console.log(chalk3.dim("  githat skills list"));
+      return;
+    }
+    console.log(chalk3.cyan(`Found ${result.skills.length} skill(s):
+`));
+    for (const skill of result.skills) {
+      console.log(formatSkill(skill));
+      console.log("");
+    }
+  } catch (err) {
+    console.error(chalk3.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+});
+
+// src/commands/skills/list.ts
+import { Command as Command2 } from "commander";
+import chalk4 from "chalk";
+function formatSkillCompact(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;
+  const name = chalk4.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}  ${chalk4.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(chalk4.dim("\nFetching skills...\n"));
+    const result = await listSkills({ type: options.type, limit });
+    if (result.skills.length === 0) {
+      console.log(chalk4.yellow("No skills found."));
+      if (options.type) {
+        console.log(chalk4.dim(`
+Try without the type filter:`));
+        console.log(chalk4.dim("  githat skills list"));
+      }
+      return;
+    }
+    const header = `${"NAME".padEnd(25)} ${"TYPE".padEnd(12)} ${"DOWNLOADS".padStart(10)}  DESCRIPTION`;
+    console.log(chalk4.dim(header));
+    console.log(chalk4.dim("\u2500".repeat(80)));
+    for (const skill of result.skills) {
+      console.log(formatSkillCompact(skill));
+    }
+    console.log(chalk4.dim("\u2500".repeat(80)));
+    console.log(chalk4.dim(`Showing ${result.skills.length} skill(s)`));
+    if (result.nextCursor) {
+      console.log(chalk4.dim("\nMore results available. Use --limit to see more."));
+    }
+    console.log(chalk4.dim("\nTo install: githat skills install <name>"));
+  } catch (err) {
+    console.error(chalk4.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+});
+
+// src/commands/skills/install.ts
+import { Command as Command3 } from "commander";
+import chalk5 from "chalk";
+import * as fs4 from "fs";
+import * as path4 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 = path4.join(destDir, ".skill-download.zip");
+  const fileStream = createWriteStream(tempZip);
+  await pipeline(response.body, fileStream);
+  await new Promise((resolve4, reject) => {
+    fs4.createReadStream(tempZip).pipe(Extract({ path: destDir })).on("close", resolve4).on("error", reject);
+  });
+  fs4.unlinkSync(tempZip);
+}
+function updateGithatLock(projectDir, skill) {
+  const lockPath = path4.join(projectDir, "githat.lock");
+  let lock = {};
+  if (fs4.existsSync(lockPath)) {
+    try {
+      lock = JSON.parse(fs4.readFileSync(lockPath, "utf-8"));
+    } catch {
+    }
+  }
+  lock[skill.slug] = {
+    version: skill.version,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  fs4.writeFileSync(lockPath, JSON.stringify(lock, null, 2));
+}
+function updateEnvExample(projectDir, manifest) {
+  if (!manifest.requires?.env?.length) return;
+  const envPath = path4.join(projectDir, ".env.local");
+  const envExamplePath = path4.join(projectDir, ".env.example");
+  let envContent = "";
+  if (fs4.existsSync(envPath)) {
+    envContent = fs4.readFileSync(envPath, "utf-8");
+  } else if (fs4.existsSync(envExamplePath)) {
+    envContent = fs4.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 (fs4.existsSync(envPath)) {
+      fs4.appendFileSync(envPath, addition);
+    } else {
+      fs4.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 ? path4.resolve(options.dir) : process.cwd();
+    const packageJsonPath = path4.join(projectDir, "package.json");
+    if (!fs4.existsSync(packageJsonPath)) {
+      console.error(chalk5.red("Error: No package.json found. Are you in a project directory?"));
+      process.exit(1);
+    }
+    console.log(chalk5.dim(`
+Fetching skill info for "${slug}"...
+`));
+    const skill = await getSkill(slug);
+    console.log(chalk5.cyan(`\u{1F4E6} ${skill.name}`));
+    console.log(chalk5.dim(`   ${skill.description}`));
+    console.log(chalk5.dim(`   Type: ${skill.type} \xB7 Author: ${skill.authorName}
+`));
+    const download = await getDownloadUrl(slug, options.version);
+    const version = download.version.version;
+    console.log(chalk5.dim(`Downloading ${skill.name}@${version}...`));
+    const skillDir = path4.join(projectDir, "githat", "skills", slug);
+    mkdirSync(skillDir, { recursive: true });
+    await downloadAndExtract(download.downloadUrl, skillDir);
+    console.log(chalk5.green(`\u2713 Downloaded to ${path4.relative(projectDir, skillDir)}`));
+    const manifestPath = path4.join(skillDir, "githat-skill.json");
+    if (fs4.existsSync(manifestPath)) {
+      const manifest = JSON.parse(fs4.readFileSync(manifestPath, "utf-8"));
+      updateEnvExample(projectDir, manifest);
+      if (manifest.requires?.env?.length) {
+        console.log(chalk5.yellow(`
+\u26A0 Required environment variables:`));
+        for (const envVar of manifest.requires.env) {
+          console.log(chalk5.dim(`   ${envVar}`));
+        }
+        console.log(chalk5.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(chalk5.yellow(`
+\u26A0 Install npm dependencies:`));
+        console.log(chalk5.dim(`   npm install ${deps}`));
+      }
+    }
+    updateGithatLock(projectDir, { slug, version });
+    console.log(chalk5.green(`
+\u2705 Successfully installed ${skill.name}@${version}
+`));
+    console.log(chalk5.dim("Next steps:"));
+    console.log(chalk5.dim(`  1. Check githat/skills/${slug}/README.md for usage`));
+    console.log(chalk5.dim("  2. Add required environment variables to .env.local"));
+    console.log(chalk5.dim("  3. Import and use the skill in your code"));
+  } catch (err) {
+    console.error(chalk5.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+});
+
+// src/commands/skills/installed.ts
+import { Command as Command4 } from "commander";
+import chalk6 from "chalk";
+import * as fs5 from "fs";
+import * as path5 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 ? path5.resolve(options.dir) : process.cwd();
+    const lockPath = path5.join(projectDir, "githat.lock");
+    if (!fs5.existsSync(lockPath)) {
+      console.log(chalk6.yellow("\nNo skills installed in this project."));
+      console.log(chalk6.dim("\nTo install a skill:"));
+      console.log(chalk6.dim("  githat skills install <slug>"));
+      return;
+    }
+    let lock;
+    try {
+      lock = JSON.parse(fs5.readFileSync(lockPath, "utf-8"));
+    } catch {
+      console.error(chalk6.red("Error: Invalid githat.lock file"));
+      process.exit(1);
+    }
+    const entries = Object.entries(lock);
+    if (entries.length === 0) {
+      console.log(chalk6.yellow("\nNo skills installed in this project."));
+      return;
+    }
+    console.log(chalk6.cyan(`
+\u{1F4E6} Installed skills (${entries.length}):
+`));
+    console.log(chalk6.dim(`${"SKILL".padEnd(30)} ${"VERSION".padEnd(12)} INSTALLED`));
+    console.log(chalk6.dim("\u2500".repeat(60)));
+    for (const [slug, entry] of entries) {
+      const date = new Date(entry.installedAt).toLocaleDateString();
+      console.log(`${chalk6.bold(slug.padEnd(30))} ${entry.version.padEnd(12)} ${chalk6.dim(date)}`);
+    }
+    console.log(chalk6.dim("\u2500".repeat(60)));
+    console.log(chalk6.dim("\nTo update a skill:"));
+    console.log(chalk6.dim("  githat skills install <slug> --version <new-version>"));
+  } catch (err) {
+    console.error(chalk6.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+});
+
+// src/commands/skills/init.ts
+import { Command as Command5 } from "commander";
+import chalk7 from "chalk";
+import * as fs6 from "fs";
+import * as path6 from "path";
+import * as p8 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(chalk7.red("Error: Name must be lowercase alphanumeric with hyphens (2-64 chars, start with letter)"));
+      process.exit(1);
+    }
+    const parentDir = options.dir ? path6.resolve(options.dir) : process.cwd();
+    const skillDir = path6.join(parentDir, name);
+    if (fs6.existsSync(skillDir)) {
+      console.error(chalk7.red(`Error: Directory "${name}" already exists`));
+      process.exit(1);
+    }
+    console.log(chalk7.cyan(`
+\u{1F4E6} Initializing skill: ${name}
+`));
+    let type;
+    if (options.type && SKILL_TYPES.includes(options.type)) {
+      type = options.type;
+    } else {
+      const result = await p8.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 (p8.isCancel(result)) {
+        p8.cancel("Operation cancelled");
+        process.exit(0);
+      }
+      type = result;
+    }
+    const description = await p8.text({
+      message: "Short description:",
+      placeholder: `A ${type} skill for...`,
+      validate: (v) => v.length < 10 ? "Description must be at least 10 characters" : void 0
+    });
+    if (p8.isCancel(description)) {
+      p8.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]
+    };
+    fs6.mkdirSync(skillDir, { recursive: true });
+    fs6.mkdirSync(path6.join(skillDir, "src"), { recursive: true });
+    fs6.writeFileSync(
+      path6.join(skillDir, "githat-skill.json"),
+      JSON.stringify(manifest, null, 2)
+    );
+    fs6.writeFileSync(
+      path6.join(skillDir, "README.md"),
+      generateReadme(manifest)
+    );
+    fs6.writeFileSync(
+      path6.join(skillDir, "src", "index.ts"),
+      generateIndexFile(manifest)
+    );
+    fs6.writeFileSync(
+      path6.join(skillDir, ".gitignore"),
+      `node_modules/
+dist/
+.env
+.env.local
+*.log
+`
+    );
+    console.log(chalk7.green(`
+\u2705 Created skill at ${skillDir}
+`));
+    console.log(chalk7.dim("Files created:"));
+    console.log(chalk7.dim(`  githat-skill.json  - Skill manifest`));
+    console.log(chalk7.dim(`  README.md          - Documentation`));
+    console.log(chalk7.dim(`  src/index.ts       - Main entry point`));
+    console.log(chalk7.dim(`  .gitignore         - Git ignore rules`));
+    console.log(chalk7.dim("\nNext steps:"));
+    console.log(chalk7.dim(`  1. cd ${name}`));
+    console.log(chalk7.dim(`  2. Edit githat-skill.json with your details`));
+    console.log(chalk7.dim(`  3. Implement your skill in src/index.ts`));
+    console.log(chalk7.dim(`  4. Publish: githat skills publish .`));
+  } catch (err) {
+    console.error(chalk7.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(chalk8.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>", "GitHat publishable key (pk_live_...)").option("--ts", "Use TypeScript (default)").option("--js", "Use JavaScript").action(async (projectName, opts) => {
   try {
     displayBanner();
     const typescript = opts.js ? false : opts.ts ? true : void 0;
@@ -616,8 +1240,9 @@ program.name("create-githat-app").description("Scaffold enterprise-grade apps wi
       initGit: answers.initGit
     });
   } catch (err) {
-    p8.cancel(chalk3.red(err.message || "Something went wrong."));
+    p9.cancel(chalk9.red(err.message || "Something went wrong."));
     process.exit(1);
   }
 });
+program.addCommand(skillsCommand);
 program.parse();