CLI v1.0.4 — fullstack project scaffolding

Add fullstack mode (Turborepo monorepo):
- projectType prompt: frontend vs fullstack
- backendFramework prompt: hono/express/fastify
- Fullstack templates: root (turbo.json, githat.yaml), apps/web, apps/api
- Hono, Express, and Fastify API templates
- Next.js web app template for monorepo
- Updated scaffold logic for monorepo structure
- Updated success message for fullstack mode

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: doble196

package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-githat-app",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "GitHat CLI — scaffold apps and manage the skills marketplace",
   "type": "module",
   "bin": {

src/constants.ts

@@ -1,4 +1,4 @@
-export const VERSION = '1.0.3';
+export const VERSION = '1.0.4';
 export const DEFAULT_API_URL = 'https://api.githat.io';
 export const DOCS_URL = 'https://githat.io/docs/sdk';
 export const DASHBOARD_URL = 'https://githat.io/dashboard/apps';
@@ -64,4 +64,49 @@ export const DEPS = {
     dependencies: { 'drizzle-orm': '^0.39.0', 'better-sqlite3': '^11.0.0' },
     devDependencies: { 'drizzle-kit': '^0.30.0', '@types/better-sqlite3': '^7.6.0' },
   },
+  // Backend frameworks for fullstack
+  hono: {
+    dependencies: {
+      hono: '^4.6.0',
+      '@hono/node-server': '^1.13.0',
+    },
+    devDependencies: {
+      typescript: '^5.9.0',
+      '@types/node': '^22.0.0',
+      tsx: '^4.19.0',
+    },
+  },
+  express: {
+    dependencies: {
+      express: '^5.0.0',
+      cors: '^2.8.5',
+    },
+    devDependencies: {
+      typescript: '^5.9.0',
+      '@types/node': '^22.0.0',
+      '@types/express': '^5.0.0',
+      '@types/cors': '^2.8.17',
+      tsx: '^4.19.0',
+    },
+  },
+  fastify: {
+    dependencies: {
+      fastify: '^5.2.0',
+      '@fastify/cors': '^10.0.0',
+    },
+    devDependencies: {
+      typescript: '^5.9.0',
+      '@types/node': '^22.0.0',
+      tsx: '^4.19.0',
+    },
+  },
+  // Turborepo for fullstack monorepo
+  turbo: {
+    devDependencies: {
+      turbo: '^2.3.0',
+    },
+  },
 } as const;
+
+export type ProjectType = 'frontend' | 'fullstack';
+export type BackendFramework = 'hono' | 'express' | 'fastify';

src/prompts/backend.ts

@@ -0,0 +1,44 @@
+import * as p from '@clack/prompts';
+import type { BackendFramework } from '../constants.js';
+
+export interface BackendAnswers {
+  backendFramework: BackendFramework;
+}
+
+export async function promptBackend(): Promise<BackendAnswers> {
+  const answers = await p.group(
+    {
+      backendFramework: () =>
+        p.select({
+          message: 'Backend framework',
+          options: [
+            {
+              value: 'hono',
+              label: 'Hono',
+              hint: 'recommended · serverless-native · 14KB',
+            },
+            {
+              value: 'express',
+              label: 'Express',
+              hint: 'classic Node.js · large ecosystem',
+            },
+            {
+              value: 'fastify',
+              label: 'Fastify',
+              hint: 'high performance · schema validation',
+            },
+          ],
+        }),
+    },
+    {
+      onCancel: () => {
+        p.cancel('Setup cancelled.');
+        process.exit(0);
+      },
+    },
+  );
+
+  return {
+    backendFramework: answers.backendFramework as BackendFramework,
+  };
+}

src/prompts/index.ts

@@ -1,17 +1,21 @@
 import * as p from '@clack/prompts';
 import { promptProject, type ProjectAnswers } from './project.js';
+import { promptProjectType, type ProjectTypeAnswers } from './project-type.js';
 import { promptFramework, type FrameworkAnswers } from './framework.js';
+import { promptBackend, type BackendAnswers } from './backend.js';
 import { promptGitHat, type GitHatAnswers } from './githat.js';
 import { promptFeatures, type FeatureAnswers } from './features.js';
 import { promptFinalize, type FinalizeAnswers } from './finalize.js';
 import { sectionHeader } from '../utils/ascii.js';
 import { detectPackageManager } from '../utils/package-manager.js';
-import { DEFAULT_API_URL } from '../constants.js';
+import { DEFAULT_API_URL, type ProjectType, type BackendFramework } from '../constants.js';
 import type { TemplateContext } from '../utils/template-engine.js';
 
 export interface AllAnswers
   extends ProjectAnswers,
+    ProjectTypeAnswers,
     FrameworkAnswers,
+    Partial<BackendAnswers>,
     GitHatAnswers,
     FeatureAnswers,
     FinalizeAnswers {}
@@ -28,6 +32,7 @@ function getDefaults(projectName: string, publishableKey?: string, typescript?:
     projectName,
     businessName: displayName,
     description: `${displayName} — Built with GitHat`,
+    projectType: 'frontend',
     framework: 'nextjs',
     typescript: typescript ?? true,
     packageManager: detectPackageManager(),
@@ -55,14 +60,21 @@ export async function runPrompts(args: {
     return getDefaults(args.initialName, args.publishableKey, args.typescript);
   }
 
-  p.intro('Let\u2019s set up your GitHat app');
+  p.intro("Let's set up your GitHat app");
 
   sectionHeader('Project');
   const project = await promptProject(args.initialName);
+  const projectType = await promptProjectType();
 
   sectionHeader('Stack');
   const framework = await promptFramework(args.typescript);
 
+  // Only prompt for backend if fullstack
+  let backend: Partial<BackendAnswers> = {};
+  if (projectType.projectType === 'fullstack') {
+    backend = await promptBackend();
+  }
+
   sectionHeader('Connect');
   const githat = await promptGitHat(args.publishableKey);
 
@@ -72,7 +84,7 @@ export async function runPrompts(args: {
   sectionHeader('Finish');
   const finalize = await promptFinalize();
 
-  return { ...project, ...framework, ...githat, ...features, ...finalize };
+  return { ...project, ...projectType, ...framework, ...backend, ...githat, ...features, ...finalize };
 }
 
 export function answersToContext(answers: AllAnswers): TemplateContext {
@@ -86,6 +98,10 @@ export function answersToContext(answers: AllAnswers): TemplateContext {
     publishableKey: answers.publishableKey,
     apiUrl: answers.apiUrl,
 
+    // Project type
+    projectType: answers.projectType,
+    backendFramework: answers.backendFramework,
+
     useDatabase: answers.databaseChoice !== 'none',
     databaseChoice: answers.databaseChoice,
     useTailwind: answers.useTailwind,

src/prompts/project-type.ts

@@ -0,0 +1,39 @@
+import * as p from '@clack/prompts';
+import type { ProjectType } from '../constants.js';
+
+export interface ProjectTypeAnswers {
+  projectType: ProjectType;
+}
+
+export async function promptProjectType(): Promise<ProjectTypeAnswers> {
+  const answers = await p.group(
+    {
+      projectType: () =>
+        p.select({
+          message: 'Project type',
+          options: [
+            {
+              value: 'frontend',
+              label: 'Frontend only',
+              hint: 'Next.js with API routes',
+            },
+            {
+              value: 'fullstack',
+              label: 'Fullstack',
+              hint: 'Next.js + separate API (Turborepo)',
+            },
+          ],
+        }),
+    },
+    {
+      onCancel: () => {
+        p.cancel('Setup cancelled.');
+        process.exit(0);
+      },
+    },
+  );
+
+  return {
+    projectType: answers.projectType as ProjectType,
+  };
+}

src/scaffold/index.ts

@@ -23,30 +23,39 @@ export async function scaffold(
     process.exit(1);
   }
 
+  const isFullstack = context.projectType === 'fullstack';
+
   // 1. Create project structure
   await withSpinner('Creating project structure...', async () => {
     fs.ensureDirSync(root);
     const templatesRoot = getTemplatesRoot();
 
-    // Render framework-specific templates
-    const frameworkDir = path.join(templatesRoot, context.framework);
-    if (!fs.existsSync(frameworkDir)) {
-      throw new Error(`Templates not found at ${frameworkDir}. This is a bug — please report it.`);
-    }
-    renderTemplateDirectory(frameworkDir, root, context);
+    if (isFullstack) {
+      // Fullstack: Turborepo monorepo structure
+      scaffoldFullstack(templatesRoot, root, context);
+    } else {
+      // Frontend only: single app
+      const frameworkDir = path.join(templatesRoot, context.framework);
+      if (!fs.existsSync(frameworkDir)) {
+        throw new Error(`Templates not found at ${frameworkDir}. This is a bug — please report it.`);
+      }
+      renderTemplateDirectory(frameworkDir, root, context);
 
-    // Render base templates (githat/ folder, env, gitignore)
-    const baseDir = path.join(templatesRoot, 'base');
-    if (fs.existsSync(baseDir)) {
-      renderTemplateDirectory(baseDir, root, context);
+      // Render base templates (githat/ folder, env, gitignore)
+      const baseDir = path.join(templatesRoot, 'base');
+      if (fs.existsSync(baseDir)) {
+        renderTemplateDirectory(baseDir, root, context);
+      }
     }
   }, 'Project structure created');
 
-  // 2. Write package.json (built programmatically for accuracy)
-  await withSpinner('Generating package.json...', async () => {
-    const pkg = buildPackageJson(context);
-    writeJson(root, 'package.json', pkg);
-  }, 'package.json generated');
+  // 2. Write package.json (built programmatically for accuracy) — skip for fullstack
+  if (!isFullstack) {
+    await withSpinner('Generating package.json...', async () => {
+      const pkg = buildPackageJson(context);
+      writeJson(root, 'package.json', pkg);
+    }, 'package.json generated');
+  }
 
   // 3. Git init
   if (options.initGit) {
@@ -82,7 +91,7 @@ export async function scaffold(
   }
 
   p.outro('Setup complete!');
-  displaySuccess(context.projectName, context.packageManager, context.framework, !!context.publishableKey);
+  displaySuccess(context.projectName, context.packageManager, context.framework, !!context.publishableKey, isFullstack);
 
   // Offer to star the repo (skip if --yes flag)
   if (!options.skipPrompts) {
@@ -100,3 +109,48 @@ export async function scaffold(
     }
   }
 }
+
+/**
+ * Scaffold a fullstack monorepo (Turborepo)
+ */
+function scaffoldFullstack(templatesRoot: string, root: string, context: TemplateContext): void {
+  const fullstackDir = path.join(templatesRoot, 'fullstack');
+
+  // 1. Render root templates (package.json, turbo.json, githat.yaml, .gitignore)
+  const rootDir = path.join(fullstackDir, 'root');
+  if (fs.existsSync(rootDir)) {
+    renderTemplateDirectory(rootDir, root, context);
+  }
+
+  // 2. Create apps directory
+  const appsDir = path.join(root, 'apps');
+  fs.ensureDirSync(appsDir);
+
+  // 3. Render web app (Next.js or React+Vite)
+  const webDir = path.join(appsDir, 'web');
+  fs.ensureDirSync(webDir);
+  const webTemplateDir = path.join(fullstackDir, `apps-web-${context.framework}`);
+  if (fs.existsSync(webTemplateDir)) {
+    renderTemplateDirectory(webTemplateDir, webDir, context);
+  } else {
+    throw new Error(`Web app templates not found at ${webTemplateDir}. This is a bug — please report it.`);
+  }
+
+  // 4. Render API app (hono, express, or fastify)
+  const apiDir = path.join(appsDir, 'api');
+  fs.ensureDirSync(apiDir);
+  const backendFramework = context.backendFramework || 'hono';
+  const apiTemplateDir = path.join(fullstackDir, `apps-api-${backendFramework}`);
+  if (fs.existsSync(apiTemplateDir)) {
+    renderTemplateDirectory(apiTemplateDir, apiDir, context);
+  } else {
+    throw new Error(`API templates not found at ${apiTemplateDir}. This is a bug — please report it.`);
+  }
+
+  // 5. Create packages directory (for shared code)
+  const packagesDir = path.join(root, 'packages');
+  fs.ensureDirSync(packagesDir);
+
+  // Create a placeholder .gitkeep to preserve the directory
+  fs.writeFileSync(path.join(packagesDir, '.gitkeep'), '');
+}