create-githat-app 0.4.1 → 0.5.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.3.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.4.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.4.0"
+      "@githat/nextjs": "^0.5.0"
     },
     devDependencies: {
       vite: "^7.0.0",
@@ -123,7 +123,7 @@ function sectionHeader(title) {
   console.log(dim(`  \u2500\u2500\u2500 ${title} ${"\u2500".repeat(lineLen)}`));
   console.log("");
 }
-function displaySuccess(projectName, packageManager, framework) {
+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("");
@@ -140,6 +140,11 @@ function displaySuccess(projectName, packageManager, framework) {
     `${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("");
@@ -305,8 +310,8 @@ async function promptGitHat(existingKey) {
       }
       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");
+      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({
@@ -543,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;
   }
 }
@@ -629,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;
@@ -649,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();

package/package.json

@@ -1,35 +1,53 @@
 {
   "name": "create-githat-app",
-  "version": "0.4.1",
-  "description": "Scaffold enterprise-grade apps with GitHat identity — for humans, AI agents, and MCP servers",
+  "version": "0.5.1",
+  "description": "GitHat CLI — scaffold apps and manage the skills marketplace",
   "type": "module",
   "bin": {
-    "create-githat-app": "./bin/index.js"
+    "create-githat-app": "./bin/index.js",
+    "githat": "./bin/index.js"
   },
-  "files": ["bin", "dist", "templates"],
+  "files": [
+    "bin",
+    "dist",
+    "templates"
+  ],
   "scripts": {
     "build": "tsup",
     "dev": "tsup --watch",
     "test": "node bin/index.js --help"
   },
   "dependencies": {
-    "@clack/prompts": "^0.9.1",
+    "@clack/prompts": "^1.0.1",
     "chalk": "^5.4.1",
-    "commander": "^13.1.0",
+    "commander": "^14.0.3",
     "figlet": "^1.8.0",
     "fs-extra": "^11.2.0",
     "gradient-string": "^3.0.0",
     "handlebars": "^4.7.8",
-    "ora": "^8.1.1"
+    "ora": "^9.3.0",
+    "unzipper": "^0.12.3"
   },
   "devDependencies": {
     "@types/figlet": "^1.7.0",
     "@types/fs-extra": "^11.0.4",
     "@types/gradient-string": "^1.1.6",
+    "@types/unzipper": "^0.10.10",
     "tsup": "^8.4.0",
     "typescript": "^5.9.0"
   },
-  "keywords": ["githat", "nextjs", "react", "vite", "create-app", "cli", "auth", "identity", "mcp", "ai-agents"],
+  "keywords": [
+    "githat",
+    "nextjs",
+    "react",
+    "vite",
+    "create-app",
+    "cli",
+    "auth",
+    "identity",
+    "mcp",
+    "ai-agents"
+  ],
   "license": "SEE LICENSE IN LICENSE",
   "publishConfig": {
     "access": "public",