create-githat-app 1.0.0

package/dist/cli.js

@@ -0,0 +1,623 @@
+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";
+
+// src/utils/ascii.ts
+import figlet from "figlet";
+import gradient from "gradient-string";
+import chalk from "chalk";
+
+// src/constants.ts
+var VERSION = "1.0.0";
+var DEFAULT_API_URL = "https://api.githat.io";
+var DASHBOARD_URL = "https://githat.io/dashboard/apps";
+var BRAND_COLORS = ["#7c3aed", "#6366f1", "#8b5cf6"];
+var DEPS = {
+  nextjs: {
+    dependencies: {
+      next: "^16.0.0",
+      react: "^19.0.0",
+      "react-dom": "^19.0.0",
+      "@githat/nextjs": "^0.2.0"
+    },
+    devDependencies: {
+      typescript: "^5.9.0",
+      "@types/react": "^19.0.0",
+      "@types/react-dom": "^19.0.0",
+      "@types/node": "^22.0.0"
+    }
+  },
+  "react-vite": {
+    dependencies: {
+      react: "^19.0.0",
+      "react-dom": "^19.0.0",
+      "react-router-dom": "^7.0.0",
+      "@githat/nextjs": "^0.2.0"
+    },
+    devDependencies: {
+      vite: "^7.0.0",
+      "@vitejs/plugin-react": "^4.4.0",
+      typescript: "^5.9.0",
+      "@types/react": "^19.0.0",
+      "@types/react-dom": "^19.0.0"
+    }
+  },
+  tailwind: {
+    devDependencies: {
+      tailwindcss: "^4.0.0",
+      "@tailwindcss/postcss": "^4.0.0",
+      postcss: "^8.4.0"
+    }
+  },
+  "tailwind-vite": {
+    devDependencies: {
+      tailwindcss: "^4.0.0",
+      "@tailwindcss/vite": "^4.0.0"
+    }
+  },
+  "prisma-postgres": {
+    dependencies: { "@prisma/client": "^6.4.0" },
+    devDependencies: { prisma: "^6.4.0" }
+  },
+  "prisma-mysql": {
+    dependencies: { "@prisma/client": "^6.4.0" },
+    devDependencies: { prisma: "^6.4.0" }
+  },
+  "drizzle-postgres": {
+    dependencies: { "drizzle-orm": "^0.39.0", postgres: "^3.4.0" },
+    devDependencies: { "drizzle-kit": "^0.30.0" }
+  },
+  "drizzle-sqlite": {
+    dependencies: { "drizzle-orm": "^0.39.0", "better-sqlite3": "^11.0.0" },
+    devDependencies: { "drizzle-kit": "^0.30.0", "@types/better-sqlite3": "^7.6.0" }
+  }
+};
+
+// src/utils/ascii.ts
+var githatGradient = gradient([...BRAND_COLORS]);
+function displayBanner() {
+  const ascii = figlet.textSync("GitHat", {
+    font: "Slant",
+    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("");
+}
+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!"));
+  console.log("");
+  console.log(`  ${chalk.cyan("cd")} ${projectName}`);
+  console.log(`  ${chalk.cyan(devCmd)}`);
+  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"));
+  console.log("");
+  console.log(chalk.dim("  Docs: https://githat.io/docs/sdk"));
+  console.log("");
+}
+
+// src/prompts/index.ts
+import * as p6 from "@clack/prompts";
+
+// src/prompts/project.ts
+import * as p from "@clack/prompts";
+
+// src/utils/validate.ts
+function validateProjectName(name) {
+  if (!name) return "Project name is required";
+  if (name.length < 2) return "Must be at least 2 characters";
+  if (name.length > 50) return "Must be 50 characters or less";
+  if (!/^[a-z0-9][a-z0-9._-]*$/.test(name)) {
+    return "Must be lowercase, start with a letter or number, and use only a-z, 0-9, -, _, .";
+  }
+  return void 0;
+}
+function validatePublishableKey(key) {
+  if (!key) return void 0;
+  if (!key.startsWith("pk_live_") && !key.startsWith("pk_test_")) {
+    return "Key must start with pk_live_ or pk_test_ (get one at githat.io/dashboard/apps)";
+  }
+  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) {
+  const answers = await p.group(
+    {
+      projectName: () => p.text({
+        message: "Project name",
+        placeholder: "my-githat-app",
+        initialValue: initialName || "",
+        validate: validateProjectName
+      }),
+      businessName: () => p.text({
+        message: "Business or app 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: ""
+      })
+    },
+    {
+      onCancel: () => {
+        p.cancel("Setup cancelled.");
+        process.exit(0);
+      }
+    }
+  );
+  return {
+    projectName: answers.projectName,
+    businessName: answers.businessName,
+    description: answers.description || `${answers.businessName} \u2014 Built with GitHat identity`
+  };
+}
+
+// src/prompts/framework.ts
+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";
+  if (userAgent.startsWith("yarn")) return "yarn";
+  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",
+    pnpm: "pnpm install",
+    yarn: "yarn",
+    bun: "bun install"
+  };
+  return cmds[pm];
+}
+
+// src/prompts/framework.ts
+async function promptFramework(typescriptOverride) {
+  const detected = 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" }
+        ]
+      }),
+      typescript: () => typescriptOverride !== void 0 ? Promise.resolve(typescriptOverride) : p2.select({
+        message: "Language",
+        options: [
+          { 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
+        }))
+      })
+    },
+    {
+      onCancel: () => {
+        p2.cancel("Setup cancelled.");
+        process.exit(0);
+      }
+    }
+  );
+  return {
+    framework: answers.framework,
+    typescript: answers.typescript,
+    packageManager: answers.packageManager
+  };
+}
+
+// src/prompts/githat.ts
+import * as p3 from "@clack/prompts";
+async function promptGitHat(existingKey) {
+  const answers = await p3.group(
+    {
+      publishableKey: () => existingKey ? Promise.resolve(existingKey) : p3.text({
+        message: "GitHat 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: () => {
+        p3.cancel("Setup cancelled.");
+        process.exit(0);
+      }
+    }
+  );
+  return {
+    publishableKey: answers.publishableKey || "",
+    apiUrl: answers.apiUrl || DEFAULT_API_URL,
+    authFeatures: answers.authFeatures || []
+  };
+}
+
+// src/prompts/features.ts
+import * as p4 from "@clack/prompts";
+async function promptFeatures() {
+  const answers = await p4.group(
+    {
+      databaseChoice: () => p4.select({
+        message: "Database",
+        options: [
+          { value: "none", label: "None \u2014 API only", 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
+      })
+    },
+    {
+      onCancel: () => {
+        p4.cancel("Setup cancelled.");
+        process.exit(0);
+      }
+    }
+  );
+  return {
+    databaseChoice: answers.databaseChoice,
+    useTailwind: answers.useTailwind,
+    includeDashboard: answers.includeDashboard,
+    includeGithatFolder: answers.includeGithatFolder
+  };
+}
+
+// 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);
+      }
+    }
+  );
+  return {
+    initGit: answers.initGit,
+    installDeps: answers.installDeps
+  };
+}
+
+// src/prompts/index.ts
+async function runPrompts(args) {
+  p6.intro("Let\u2019s set up your GitHat app");
+  const project = await promptProject(args.initialName);
+  const framework = await promptFramework(args.typescript);
+  const githat = await promptGitHat(args.publishableKey);
+  const features = await promptFeatures();
+  const finalize = await promptFinalize();
+  return { ...project, ...framework, ...githat, ...features, ...finalize };
+}
+function answersToContext(answers) {
+  return {
+    projectName: answers.projectName,
+    businessName: answers.businessName,
+    description: answers.description,
+    framework: answers.framework,
+    typescript: answers.typescript,
+    packageManager: answers.packageManager,
+    publishableKey: answers.publishableKey,
+    apiUrl: answers.apiUrl,
+    useDatabase: answers.databaseChoice !== "none",
+    databaseChoice: answers.databaseChoice,
+    useTailwind: answers.useTailwind,
+    includeDashboard: answers.includeDashboard,
+    includeGithatFolder: answers.includeGithatFolder,
+    includeForgotPassword: answers.authFeatures.includes("forgot-password"),
+    includeEmailVerification: answers.authFeatures.includes("email-verification"),
+    includeOrgManagement: answers.authFeatures.includes("org-management"),
+    includeMcpModule: answers.authFeatures.includes("mcp-servers"),
+    includeAgentModule: answers.authFeatures.includes("ai-agents"),
+    ext: answers.typescript ? "tsx" : "jsx",
+    configExt: answers.typescript ? "ts" : "js"
+  };
+}
+
+// src/scaffold/index.ts
+import fs3 from "fs-extra";
+import path3 from "path";
+import { execSync as execSync3 } from "child_process";
+import * as p7 from "@clack/prompts";
+import chalk2 from "chalk";
+
+// src/utils/template-engine.ts
+import Handlebars from "handlebars";
+import fs from "fs-extra";
+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");
+Handlebars.registerHelper("ifEquals", function(a, b, options) {
+  return a === b ? options.fn(this) : options.inverse(this);
+});
+function getTemplatesRoot() {
+  return TEMPLATES_ROOT;
+}
+function renderTemplate(templatePath, context) {
+  const content = fs.readFileSync(templatePath, "utf-8");
+  const template = Handlebars.compile(content, { noEscape: true });
+  return template(context);
+}
+function renderTemplateDirectory(templateDir, outputDir, context) {
+  const entries = fs.readdirSync(templateDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(templateDir, entry.name);
+    if (entry.isDirectory()) {
+      const outDirName = entry.name;
+      const outPath = path.join(outputDir, outDirName);
+      fs.ensureDirSync(outPath);
+      renderTemplateDirectory(srcPath, outPath, context);
+    } else if (entry.name.endsWith(".hbs")) {
+      const outputName = entry.name.replace(/\.hbs$/, "");
+      const finalName = context.typescript ? outputName : outputName.replace(/\.tsx$/, ".jsx").replace(/\.ts$/, ".js");
+      const outPath = path.join(outputDir, finalName);
+      const rendered = renderTemplate(srcPath, context);
+      if (rendered.trim()) {
+        fs.ensureDirSync(path.dirname(outPath));
+        fs.writeFileSync(outPath, rendered, "utf-8");
+      }
+    } else {
+      const outPath = path.join(outputDir, entry.name);
+      fs.copySync(srcPath, outPath);
+    }
+  }
+}
+
+// src/scaffold/file-writer.ts
+import fs2 from "fs-extra";
+import path2 from "path";
+function writeFile(root, relativePath, content) {
+  const fullPath = path2.join(root, relativePath);
+  fs2.ensureDirSync(path2.dirname(fullPath));
+  fs2.writeFileSync(fullPath, content, "utf-8");
+}
+function writeJson(root, relativePath, data) {
+  writeFile(root, relativePath, JSON.stringify(data, null, 2) + "\n");
+}
+
+// src/scaffold/package-builder.ts
+function buildPackageJson(ctx) {
+  const isNext = ctx.framework === "nextjs";
+  const deps = {
+    ...isNext ? DEPS.nextjs.dependencies : DEPS["react-vite"].dependencies
+  };
+  const devDeps = {
+    ...isNext ? DEPS.nextjs.devDependencies : DEPS["react-vite"].devDependencies
+  };
+  if (ctx.useTailwind) {
+    if (isNext) {
+      Object.assign(devDeps, DEPS.tailwind.devDependencies);
+    } else {
+      Object.assign(devDeps, DEPS["tailwind-vite"].devDependencies);
+    }
+  }
+  if (ctx.useDatabase && ctx.databaseChoice !== "none") {
+    const dbDeps = DEPS[ctx.databaseChoice];
+    if (dbDeps && "dependencies" in dbDeps) {
+      Object.assign(deps, dbDeps.dependencies);
+    }
+    if (dbDeps && "devDependencies" in dbDeps) {
+      Object.assign(devDeps, dbDeps.devDependencies);
+    }
+  }
+  if (!ctx.typescript) {
+    delete devDeps.typescript;
+    delete devDeps["@types/react"];
+    delete devDeps["@types/react-dom"];
+    delete devDeps["@types/node"];
+    delete devDeps["@types/better-sqlite3"];
+  }
+  const scripts = isNext ? { dev: "next dev", build: "next build", start: "next start", lint: "next lint" } : { dev: "vite", build: "vite build", preview: "vite preview" };
+  if (ctx.databaseChoice.startsWith("prisma")) {
+    scripts["db:push"] = "prisma db push";
+    scripts["db:studio"] = "prisma studio";
+    scripts["db:generate"] = "prisma generate";
+  } else if (ctx.databaseChoice.startsWith("drizzle")) {
+    scripts["db:push"] = "drizzle-kit push";
+    scripts["db:generate"] = "drizzle-kit generate";
+    scripts["db:migrate"] = "drizzle-kit migrate";
+  }
+  return {
+    name: ctx.projectName,
+    version: "0.1.0",
+    private: true,
+    ...isNext ? {} : { type: "module" },
+    scripts,
+    dependencies: sortKeys(deps),
+    devDependencies: sortKeys(devDeps)
+  };
+}
+function sortKeys(obj) {
+  return Object.fromEntries(Object.entries(obj).sort(([a], [b]) => a.localeCompare(b)));
+}
+
+// src/utils/spinner.ts
+import ora from "ora";
+function createSpinner(text3) {
+  return ora({ text: text3, color: "magenta" });
+}
+async function withSpinner(text3, fn, successText) {
+  const spinner = createSpinner(text3);
+  spinner.start();
+  try {
+    const result = await fn();
+    spinner.succeed(successText || text3);
+    return result;
+  } catch (err) {
+    spinner.fail(text3);
+    throw err;
+  }
+}
+
+// src/utils/git.ts
+import { execSync as execSync2 } from "child_process";
+function initGit(cwd) {
+  try {
+    execSync2("git init", { cwd, stdio: "ignore" });
+    execSync2("git add -A", { cwd, stdio: "ignore" });
+    execSync2('git commit -m "Initial commit from create-githat-app"', {
+      cwd,
+      stdio: "ignore"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/scaffold/index.ts
+async function scaffold(context, options) {
+  const root = path3.resolve(process.cwd(), context.projectName);
+  if (fs3.existsSync(root)) {
+    p7.cancel(`Directory "${context.projectName}" already exists.`);
+    process.exit(1);
+  }
+  await withSpinner("Creating project structure...", async () => {
+    fs3.ensureDirSync(root);
+    const templatesRoot = getTemplatesRoot();
+    const frameworkDir = path3.join(templatesRoot, context.framework);
+    if (fs3.existsSync(frameworkDir)) {
+      renderTemplateDirectory(frameworkDir, root, context);
+    }
+    const baseDir = path3.join(templatesRoot, "base");
+    if (fs3.existsSync(baseDir)) {
+      renderTemplateDirectory(baseDir, root, context);
+    }
+  }, "Project structure created");
+  await withSpinner("Generating package.json...", async () => {
+    const pkg = buildPackageJson(context);
+    writeJson(root, "package.json", pkg);
+  }, "package.json generated");
+  if (options.initGit) {
+    const gitSpinner = createSpinner("Initializing git repository...");
+    gitSpinner.start();
+    const ok = initGit(root);
+    if (ok) {
+      gitSpinner.succeed("Git repository initialized");
+    } else {
+      gitSpinner.warn("Could not initialize git \u2014 is git installed?");
+    }
+  }
+  if (options.installDeps) {
+    const installCmd = getInstallCommand(context.packageManager);
+    await withSpinner(
+      `Installing dependencies with ${context.packageManager}...`,
+      async () => {
+        try {
+          execSync3(installCmd, { cwd: root, stdio: "ignore", timeout: 12e4 });
+        } catch (err) {
+          const msg = err.message || "";
+          if (msg.includes("TIMEOUT")) {
+            p7.log.warn(`Install timed out. Run ${chalk2.cyan(installCmd)} manually.`);
+          } else {
+            p7.log.warn(`Could not auto-install. Run ${chalk2.cyan(installCmd)} manually.`);
+          }
+        }
+      },
+      "Dependencies installed"
+    );
+  }
+  p7.outro("Setup complete!");
+  displaySuccess(context.projectName, context.packageManager, context.framework);
+}
+
+// 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) => {
+  try {
+    displayBanner();
+    const typescript = opts.js ? false : opts.ts ? true : void 0;
+    const answers = await runPrompts({
+      initialName: projectName,
+      publishableKey: opts.key,
+      typescript
+    });
+    const context = answersToContext(answers);
+    await scaffold(context, {
+      installDeps: answers.installDeps,
+      initGit: answers.initGit
+    });
+  } catch (err) {
+    p8.cancel(chalk3.red(err.message || "Something went wrong."));
+    process.exit(1);
+  }
+});
+program.parse();

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "create-githat-app",
+  "version": "1.0.0",
+  "description": "Scaffold enterprise-grade apps with GitHat identity — for humans, AI agents, and MCP servers",
+  "type": "module",
+  "bin": {
+    "create-githat-app": "./bin/index.js"
+  },
+  "files": ["bin", "dist", "templates"],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "node bin/index.js --help"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.9.1",
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "figlet": "^1.8.0",
+    "fs-extra": "^11.2.0",
+    "gradient-string": "^3.0.0",
+    "handlebars": "^4.7.8",
+    "ora": "^8.1.1"
+  },
+  "devDependencies": {
+    "@types/figlet": "^1.7.0",
+    "@types/fs-extra": "^11.0.4",
+    "@types/gradient-string": "^1.1.6",
+    "tsup": "^8.4.0",
+    "typescript": "^5.9.0"
+  },
+  "keywords": ["githat", "nextjs", "react", "vite", "create-app", "cli", "auth", "identity", "mcp", "ai-agents"],
+  "license": "SEE LICENSE IN LICENSE",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/GitHat-IO/create-githat-app.git"
+  }
+}

package/templates/base/.env.example.hbs

@@ -0,0 +1,13 @@
+# GitHat Identity
+{{#ifEquals framework "nextjs"}}
+NEXT_PUBLIC_GITHAT_PUBLISHABLE_KEY=pk_test_your_key_here
+NEXT_PUBLIC_GITHAT_API_URL={{apiUrl}}
+{{else}}
+VITE_GITHAT_PUBLISHABLE_KEY=pk_test_your_key_here
+VITE_GITHAT_API_URL={{apiUrl}}
+{{/ifEquals}}
+{{#if useDatabase}}
+
+# Database
+DATABASE_URL="postgresql://user:password@localhost:5432/{{projectName}}"
+{{/if}}

package/templates/base/.env.local.hbs

@@ -0,0 +1,10 @@
+{{#ifEquals framework "nextjs"}}
+NEXT_PUBLIC_GITHAT_PUBLISHABLE_KEY={{publishableKey}}
+NEXT_PUBLIC_GITHAT_API_URL={{apiUrl}}
+{{else}}
+VITE_GITHAT_PUBLISHABLE_KEY={{publishableKey}}
+VITE_GITHAT_API_URL={{apiUrl}}
+{{/ifEquals}}
+{{#if useDatabase}}
+DATABASE_URL="postgresql://user:password@localhost:5432/{{projectName}}"
+{{/if}}

package/templates/base/.gitignore.hbs

@@ -0,0 +1,11 @@
+node_modules
+{{#ifEquals framework "nextjs"}}
+.next
+out
+{{else}}
+dist
+{{/ifEquals}}
+.env
+.env*.local
+.DS_Store
+*.tgz