create-githat-app 1.0.10 → 1.0.13

package/dist/cli.js

@@ -2,8 +2,8 @@ import { createRequire } from 'module'; const require = createRequire(import.met
 
 // src/cli.ts
 import { Command as Command7 } from "commander";
-import * as p11 from "@clack/prompts";
-import chalk9 from "chalk";
+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.0.10";
+var VERSION = "1.0.13";
 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.2.5"
+      "@githat/nextjs": "^0.5.0",
+      "@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.2.5"
+      "@githat/nextjs": "^0.5.0",
+      "@githat/ui": "^1.0.0"
     },
     devDependencies: {
       vite: "^7.0.0",
@@ -657,11 +659,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 p9 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";
@@ -809,27 +811,109 @@ 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)) {
-    p9.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();
     if (isFullstack) {
       scaffoldFullstack(templatesRoot, root, context);
     } else {
-      const frameworkDir = path3.join(templatesRoot, context.framework);
-      if (!fs3.existsSync(frameworkDir)) {
+      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 = path3.join(templatesRoot, "base");
-      if (fs3.existsSync(baseDir)) {
+      const baseDir = path4.join(templatesRoot, "base");
+      if (fs4.existsSync(baseDir)) {
         renderTemplateDirectory(baseDir, root, context);
       }
     }
@@ -840,6 +924,9 @@ async function scaffold(context, options) {
       writeJson(root, "package.json", pkg);
     }, "package.json generated");
   }
+  if (!isFullstack && context.framework === "nextjs") {
+    await registerApp(context.projectName, root);
+  }
   if (options.initGit) {
     const gitSpinner = createSpinner("Initializing git repository...");
     gitSpinner.start();
@@ -860,69 +947,69 @@ async function scaffold(context, options) {
         } catch (err) {
           const msg = err.message || "";
           if (msg.includes("TIMEOUT")) {
-            p9.log.warn(`Install timed out. Run ${chalk2.cyan(installCmd)} manually.`);
+            p10.log.warn(`Install timed out. Run ${chalk3.cyan(installCmd)} manually.`);
           } else {
-            p9.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"
     );
   }
-  p9.outro("Setup complete!");
+  p10.outro("Setup complete!");
   displaySuccess(context.projectName, context.packageManager, context.framework, !!context.publishableKey, isFullstack);
   if (!options.skipPrompts) {
-    const starPrompt = await p9.confirm({
+    const starPrompt = await p10.confirm({
       message: "Star GitHat on GitHub? (helps us grow!)",
       initialValue: false
     });
-    if (!p9.isCancel(starPrompt) && starPrompt) {
+    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 {
-        p9.log.info("Visit https://github.com/GitHat-IO/githat to star us!");
+        p10.log.info("Visit https://github.com/GitHat-IO/githat to star us!");
       }
     }
   }
 }
 function scaffoldFullstack(templatesRoot, root, context) {
-  const fullstackDir = path3.join(templatesRoot, "fullstack");
-  const rootDir = path3.join(fullstackDir, "root");
-  if (fs3.existsSync(rootDir)) {
+  const fullstackDir = path4.join(templatesRoot, "fullstack");
+  const rootDir = path4.join(fullstackDir, "root");
+  if (fs4.existsSync(rootDir)) {
     renderTemplateDirectory(rootDir, root, context);
   }
-  const appsDir = path3.join(root, "apps");
-  fs3.ensureDirSync(appsDir);
-  const webDir = path3.join(appsDir, "web");
-  fs3.ensureDirSync(webDir);
-  const webTemplateDir = path3.join(fullstackDir, `apps-web-${context.framework}`);
-  if (fs3.existsSync(webTemplateDir)) {
+  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 = path3.join(appsDir, "api");
-  fs3.ensureDirSync(apiDir);
+  const apiDir = path4.join(appsDir, "api");
+  fs4.ensureDirSync(apiDir);
   const backendFramework = context.backendFramework || "hono";
-  const apiTemplateDir = path3.join(fullstackDir, `apps-api-${backendFramework}`);
-  if (fs3.existsSync(apiTemplateDir)) {
+  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 = path3.join(root, "packages");
-  fs3.ensureDirSync(packagesDir);
-  fs3.writeFileSync(path3.join(packagesDir, ".gitkeep"), "");
+  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 chalk8 from "chalk";
+import chalk9 from "chalk";
 
 // src/commands/skills/search.ts
 import { Command } from "commander";
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 
 // src/commands/skills/api.ts
 async function fetchApi(endpoint, options = {}) {
@@ -970,99 +1057,99 @@ async function getDownloadUrl(slug, version) {
 // 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
+    template: chalk4.blue,
+    integration: chalk4.green,
+    ui: chalk4.magenta,
+    ai: chalk4.yellow,
+    workflow: chalk4.cyan
   };
-  const typeColor = typeColors[skill.type] || chalk3.white;
+  const typeColor = typeColors[skill.type] || chalk4.white;
   return [
-    `${chalk3.bold(skill.name)} ${chalk3.dim(`@${skill.latestVersion}`)}`,
+    `${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}`,
-    `  ${chalk3.dim(`githat skills install ${skill.slug}`)}`
+    `  ${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(chalk3.dim(`
+    console.log(chalk4.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"));
+      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(chalk3.cyan(`Found ${result.skills.length} skill(s):
+    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(chalk3.red(`Error: ${err.message}`));
+    console.error(chalk4.red(`Error: ${err.message}`));
     process.exit(1);
   }
 });
 
 // src/commands/skills/list.ts
 import { Command as Command2 } from "commander";
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 function formatSkillCompact(skill) {
   const typeColors = {
-    template: chalk4.blue,
-    integration: chalk4.green,
-    ui: chalk4.magenta,
-    ai: chalk4.yellow,
-    workflow: chalk4.cyan
+    template: chalk5.blue,
+    integration: chalk5.green,
+    ui: chalk5.magenta,
+    ai: chalk5.yellow,
+    workflow: chalk5.cyan
   };
-  const typeColor = typeColors[skill.type] || chalk4.white;
-  const name = chalk4.bold(skill.name.padEnd(25));
+  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}  ${chalk4.dim(desc)}`;
+  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(chalk4.dim("\nFetching skills...\n"));
+    console.log(chalk5.dim("\nFetching skills...\n"));
     const result = await listSkills({ type: options.type, limit });
     if (result.skills.length === 0) {
-      console.log(chalk4.yellow("No skills found."));
+      console.log(chalk5.yellow("No skills found."));
       if (options.type) {
-        console.log(chalk4.dim(`
+        console.log(chalk5.dim(`
 Try without the type filter:`));
-        console.log(chalk4.dim("  githat skills list"));
+        console.log(chalk5.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)));
+    console.log(chalk5.dim(header));
+    console.log(chalk5.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)`));
+    console.log(chalk5.dim("\u2500".repeat(80)));
+    console.log(chalk5.dim(`Showing ${result.skills.length} skill(s)`));
     if (result.nextCursor) {
-      console.log(chalk4.dim("\nMore results available. Use --limit to see more."));
+      console.log(chalk5.dim("\nMore results available. Use --limit to see more."));
     }
-    console.log(chalk4.dim("\nTo install: githat skills install <name>"));
+    console.log(chalk5.dim("\nTo install: githat skills install <name>"));
   } catch (err) {
-    console.error(chalk4.red(`Error: ${err.message}`));
+    console.error(chalk5.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 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";
@@ -1071,20 +1158,20 @@ async function downloadAndExtract(url, destDir) {
   if (!response.ok) {
     throw new Error(`Download failed: ${response.statusText}`);
   }
-  const tempZip = path4.join(destDir, ".skill-download.zip");
+  const tempZip = path5.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);
+    fs5.createReadStream(tempZip).pipe(Extract({ path: destDir })).on("close", resolve4).on("error", reject);
   });
-  fs4.unlinkSync(tempZip);
+  fs5.unlinkSync(tempZip);
 }
 function updateGithatLock(projectDir, skill) {
-  const lockPath = path4.join(projectDir, "githat.lock");
+  const lockPath = path5.join(projectDir, "githat.lock");
   let lock = {};
-  if (fs4.existsSync(lockPath)) {
+  if (fs5.existsSync(lockPath)) {
     try {
-      lock = JSON.parse(fs4.readFileSync(lockPath, "utf-8"));
+      lock = JSON.parse(fs5.readFileSync(lockPath, "utf-8"));
     } catch {
     }
   }
@@ -1092,17 +1179,17 @@ function updateGithatLock(projectDir, skill) {
     version: skill.version,
     installedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  fs4.writeFileSync(lockPath, JSON.stringify(lock, null, 2));
+  fs5.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");
+  const envPath = path5.join(projectDir, ".env.local");
+  const envExamplePath = path5.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");
+  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())
@@ -1118,10 +1205,10 @@ function updateEnvExample(projectDir, manifest) {
 # Added by skill install
 ${newVars.join("\n")}
 `;
-    if (fs4.existsSync(envPath)) {
-      fs4.appendFileSync(envPath, addition);
+    if (fs5.existsSync(envPath)) {
+      fs5.appendFileSync(envPath, addition);
     } else {
-      fs4.writeFileSync(envPath, `# Environment variables
+      fs5.writeFileSync(envPath, `# Environment variables
 ${newVars.join("\n")}
 `);
     }
@@ -1129,112 +1216,112 @@ ${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?"));
+    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(chalk5.dim(`
+    console.log(chalk6.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}
+    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(chalk5.dim(`Downloading ${skill.name}@${version}...`));
-    const skillDir = path4.join(projectDir, "githat", "skills", slug);
+    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(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"));
+    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(chalk5.yellow(`
+        console.log(chalk6.yellow(`
 \u26A0 Required environment variables:`));
         for (const envVar of manifest.requires.env) {
-          console.log(chalk5.dim(`   ${envVar}`));
+          console.log(chalk6.dim(`   ${envVar}`));
         }
-        console.log(chalk5.dim(`
+        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(chalk5.yellow(`
+        console.log(chalk6.yellow(`
 \u26A0 Install npm dependencies:`));
-        console.log(chalk5.dim(`   npm install ${deps}`));
+        console.log(chalk6.dim(`   npm install ${deps}`));
       }
     }
     updateGithatLock(projectDir, { slug, version });
-    console.log(chalk5.green(`
+    console.log(chalk6.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"));
+    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(chalk5.red(`Error: ${err.message}`));
+    console.error(chalk6.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";
+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 ? 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>"));
+    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(fs5.readFileSync(lockPath, "utf-8"));
+      lock = JSON.parse(fs6.readFileSync(lockPath, "utf-8"));
     } catch {
-      console.error(chalk6.red("Error: Invalid githat.lock file"));
+      console.error(chalk7.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."));
+      console.log(chalk7.yellow("\nNo skills installed in this project."));
       return;
     }
-    console.log(chalk6.cyan(`
+    console.log(chalk7.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)));
+    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(`${chalk6.bold(slug.padEnd(30))} ${entry.version.padEnd(12)} ${chalk6.dim(date)}`);
+      console.log(`${chalk7.bold(slug.padEnd(30))} ${entry.version.padEnd(12)} ${chalk7.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>"));
+    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(chalk6.red(`Error: ${err.message}`));
+    console.error(chalk7.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 p10 from "@clack/prompts";
+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}
@@ -1366,23 +1453,23 @@ function toPascalCase(str) {
 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)"));
+      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 ? 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`));
+    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(chalk7.cyan(`
+    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 p10.select({
+      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.)" },
@@ -1392,19 +1479,19 @@ var initCommand = new Command5("init").description("Initialize a new skill packa
           { value: "workflow", label: "Workflow", hint: "Automation recipes" }
         ]
       });
-      if (p10.isCancel(result)) {
-        p10.cancel("Operation cancelled");
+      if (p11.isCancel(result)) {
+        p11.cancel("Operation cancelled");
         process.exit(0);
       }
       type = result;
     }
-    const description = await p10.text({
+    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 (p10.isCancel(description)) {
-      p10.cancel("Operation cancelled");
+    if (p11.isCancel(description)) {
+      p11.cancel("Operation cancelled");
       process.exit(0);
     }
     const manifest = {
@@ -1429,22 +1516,22 @@ var initCommand = new Command5("init").description("Initialize a new skill packa
       },
       keywords: [type]
     };
-    fs6.mkdirSync(skillDir, { recursive: true });
-    fs6.mkdirSync(path6.join(skillDir, "src"), { recursive: true });
-    fs6.writeFileSync(
-      path6.join(skillDir, "githat-skill.json"),
+    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)
     );
-    fs6.writeFileSync(
-      path6.join(skillDir, "README.md"),
+    fs7.writeFileSync(
+      path7.join(skillDir, "README.md"),
       generateReadme(manifest)
     );
-    fs6.writeFileSync(
-      path6.join(skillDir, "src", "index.ts"),
+    fs7.writeFileSync(
+      path7.join(skillDir, "src", "index.ts"),
       generateIndexFile(manifest)
     );
-    fs6.writeFileSync(
-      path6.join(skillDir, ".gitignore"),
+    fs7.writeFileSync(
+      path7.join(skillDir, ".gitignore"),
       `node_modules/
 dist/
 .env
@@ -1452,21 +1539,21 @@ dist/
 *.log
 `
     );
-    console.log(chalk7.green(`
+    console.log(chalk8.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 .`));
+    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(chalk7.red(`Error: ${err.message}`));
+    console.error(chalk8.red(`Error: ${err.message}`));
     process.exit(1);
   }
 });
@@ -1474,7 +1561,7 @@ dist/
 // 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(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)");
@@ -1497,7 +1584,7 @@ program.command("create [project-name]", { isDefault: true }).description("Scaff
     displayBanner();
     const typescript = opts.js ? false : opts.ts ? true : void 0;
     if (opts.yes && !projectName) {
-      p11.cancel(chalk9.red("Project name is required when using --yes flag"));
+      p12.cancel(chalk10.red("Project name is required when using --yes flag"));
       process.exit(1);
     }
     const answers = await runPrompts({
@@ -1515,7 +1602,7 @@ program.command("create [project-name]", { isDefault: true }).description("Scaff
       skipPrompts: opts.yes
     });
   } catch (err) {
-    p11.cancel(chalk9.red(err.message || "Something went wrong."));
+    p12.cancel(chalk10.red(err.message || "Something went wrong."));
     process.exit(1);
   }
 });