@husar.ai/cli 0.4.3 → 0.4.5

package/src/functions/create.ts

@@ -12,17 +12,17 @@
 import { spawn } from 'node:child_process';
 import { promises as fs } from 'node:fs';
 import { join, resolve } from 'node:path';
-import * as readline from 'node:readline';
 
 import { getCloudAuth, ProjectAuth } from '../auth/config.js';
 import { startCloudLoginFlow, startPanelLoginFlow } from '../auth/login.js';
 import { getProjects, CloudProject, verifyAccessToken } from '../auth/api.js';
+import { log, spinner, select, input, successBox, errorBox, nextSteps, header, theme, chalk } from '../ui.js';
 
 export interface CreateOptions {
   /** Project directory name */
   projectName?: string;
-  /** Framework to use: nextjs or vite */
-  framework: 'nextjs' | 'vite';
+  /** Framework to use: nextjs, vite, or clean */
+  framework?: 'nextjs' | 'vite' | 'clean';
   /** Skip npm install after scaffolding */
   skipInstall?: boolean;
 }
@@ -35,235 +35,227 @@ export interface CreateOptions {
  * Run the create command
  */
 export async function runCreateCommand(options: CreateOptions): Promise<void> {
-  console.log('\n🚀 Husar.ai Project Creator\n');
-
   // ═══════════════════════════════════════════════════════════════════════
   // STEP 1: How to connect to CMS?
   // ═══════════════════════════════════════════════════════════════════════
 
-  const connectionMethod = await promptConnectionMethod();
+  header('Step 1: Connect to CMS');
+
+  const connectionMethod = await select<'manual' | 'cloud'>('How do you want to connect?', [
+    {
+      name: 'cloud',
+      message: 'Login to husar.ai',
+      hint: 'Recommended - select from your projects',
+    },
+    {
+      name: 'manual',
+      message: 'Enter URL manually',
+      hint: 'For self-hosted or custom instances',
+    },
+  ]);
+
   let panelHost: string;
 
   if (connectionMethod === 'manual') {
-    // User enters URL manually
-    panelHost = await promptManualUrl();
+    panelHost = await input('Enter your CMS panel URL', 'https://');
+
+    // Basic validation
+    if (!panelHost.startsWith('http://') && !panelHost.startsWith('https://')) {
+      errorBox('URL must start with http:// or https://');
+      process.exit(1);
+    }
   } else {
     // Cloud login flow → select project
     const cloudAuth = await ensureCloudLogin();
     if (!cloudAuth) {
-      console.error('\n❌ Cloud authentication failed. Please try again.');
+      errorBox('Cloud authentication failed. Please try again.');
       process.exit(1);
     }
 
     // Fetch user's projects
-    console.log('\n📦 Fetching your projects...\n');
+    const spin = spinner('Fetching your projects...');
     const projects = await getProjects(cloudAuth.accessToken);
+    spin.stop();
 
     if (projects.length === 0) {
-      console.log('❌ No projects found in your account.');
-      console.log('   Create a project at https://admin.husar.ai first.\n');
+      errorBox(
+        'No projects found in your account.\n\n' + `Create a project at ${theme.link('https://admin.husar.ai')} first.`,
+        'No Projects',
+      );
       process.exit(1);
     }
 
     // Let user select a project
     const selectedProject = await promptSelectProject(projects);
     panelHost = selectedProject.adminURL;
-    console.log(`\n📌 Selected: ${selectedProject.name}`);
+    log.done(`Selected: ${theme.info(selectedProject.name)}`);
   }
 
   // ═══════════════════════════════════════════════════════════════════════
   // STEP 2: Panel CMS login (get adminToken)
   // ═══════════════════════════════════════════════════════════════════════
 
-  console.log('\n🔐 Opening browser for CMS authentication...');
-  console.log("   You'll need your SUPERADMIN credentials (from the welcome email)\n");
+  header('Step 2: CMS Authentication');
+
+  log.info('Opening browser for CMS authentication...');
+  log.dim("You'll need your SUPERADMIN credentials (from the welcome email)");
+  log.blank();
 
   const panelAuth = await startPanelLoginFlow(panelHost);
 
   if (!panelAuth.success || !panelAuth.project) {
-    console.error('\n❌ CMS authentication failed:', panelAuth.error ?? 'Unknown error');
+    errorBox(panelAuth.error ?? 'Unknown error', 'CMS Authentication Failed');
     process.exit(1);
   }
 
   const project = panelAuth.project;
-  console.log(`\n✅ Connected to: ${project.projectName}`);
-  console.log(`   Host: ${project.host}\n`);
+  log.success(`Connected to: ${theme.info(project.projectName)}`);
+  log.dim(`Host: ${project.host}`);
 
   // ═══════════════════════════════════════════════════════════════════════
   // STEP 3: Get project name (directory)
   // ═══════════════════════════════════════════════════════════════════════
 
-  const projectName = options.projectName || (await promptProjectName(project.projectName));
+  header('Step 3: Project Setup');
+
+  const defaultName = project.projectName.replace(/[^a-zA-Z0-9-_]/g, '-').toLowerCase();
+  const projectName = options.projectName || (await input('Project directory name', defaultName));
+
   if (!projectName) {
-    console.error('❌ Project name is required.');
+    errorBox('Project name is required.');
     process.exit(1);
   }
 
   const projectPath = resolve(process.cwd(), projectName);
 
   // ═══════════════════════════════════════════════════════════════════════
-  // STEP 4: Run framework CLI
+  // STEP 4: Select framework
   // ═══════════════════════════════════════════════════════════════════════
 
-  console.log(`\n📦 Creating ${options.framework === 'nextjs' ? 'Next.js' : 'Vite + React'} project...\n`);
+  const framework =
+    options.framework ||
+    (await select<'nextjs' | 'vite' | 'clean'>('Which template would you like?', [
+      {
+        name: 'nextjs',
+        message: 'Next.js',
+        hint: 'Recommended - Full-stack React with SSR',
+      },
+      {
+        name: 'vite',
+        message: 'Vite + React',
+        hint: 'Fast build tool with React & TypeScript',
+      },
+      {
+        name: 'clean',
+        message: 'Clean (no framework)',
+        hint: 'Just npm init - bring your own setup',
+      },
+    ]));
 
-  const frameworkSuccess = await runFrameworkCli(options.framework, projectName);
-  if (!frameworkSuccess) {
-    console.error('\n❌ Framework CLI failed. Please check the output above.');
-    process.exit(1);
+  // ═══════════════════════════════════════════════════════════════════════
+  // STEP 5: Run framework CLI or init clean project
+  // ═══════════════════════════════════════════════════════════════════════
+
+  header('Step 4: Creating Project');
+
+  if (framework === 'clean') {
+    const spin = spinner('Initializing clean project...');
+    const initSuccess = await initCleanProject(projectName);
+    if (!initSuccess) {
+      spin.fail('Project initialization failed');
+      process.exit(1);
+    }
+    spin.succeed('Project initialized');
+  } else {
+    const frameworkLabel = framework === 'nextjs' ? 'Next.js' : 'Vite + React';
+    log.step(`Creating ${frameworkLabel} project...`);
+    log.blank();
+
+    const frameworkSuccess = await runFrameworkCli(framework, projectName);
+    if (!frameworkSuccess) {
+      errorBox('Framework CLI failed. Please check the output above.');
+      process.exit(1);
+    }
   }
 
   // ═══════════════════════════════════════════════════════════════════════
-  // STEP 5: Add Husar configuration (with hybrid storage)
+  // STEP 6: Add Husar configuration (with hybrid storage)
   // ═══════════════════════════════════════════════════════════════════════
 
-  console.log('\n⚙️  Adding Husar configuration...\n');
-  await addHusarConfig(projectPath, project, options.framework);
+  header('Step 5: Configuring Husar');
+
+  const configSpin = spinner('Adding configuration...');
+  await addHusarConfig(projectPath, project, framework);
+  configSpin.succeed('Configuration added');
+
+  log.substep('husar.json - CMS configuration');
+  log.substep('.env.local - Credentials (keep secret!)');
+  log.substep('opencode.jsonc - MCP integration');
+  log.substep('.opencode/command/husar.md - MCP docs');
 
   // ═══════════════════════════════════════════════════════════════════════
-  // STEP 6: Install Husar packages
+  // STEP 7: Install Husar packages
   // ═══════════════════════════════════════════════════════════════════════
 
   if (!options.skipInstall) {
-    console.log('\n📥 Installing Husar packages...\n');
+    log.blank();
+    const installSpin = spinner('Installing Husar packages...');
     await installHusarPackages(projectPath);
+    installSpin.succeed('Packages installed');
+    log.substep('@husar.ai/ssr');
+    log.substep('@husar.ai/render');
   }
 
   // ═══════════════════════════════════════════════════════════════════════
-  // STEP 7: Generate CMS files
+  // STEP 8: Generate CMS files
   // ═══════════════════════════════════════════════════════════════════════
 
-  console.log('\n🔧 Generating CMS client...\n');
-  await generateCmsClient(projectPath, options.framework);
+  log.blank();
+  const genSpin = spinner('Generating CMS client...');
+  await generateCmsClient(projectPath, framework);
+  genSpin.succeed('CMS client generated');
+  log.substep('cms/zeus/ - GraphQL client');
+  log.substep('cms/ssr.ts - Server client');
+  log.substep('cms/react.ts - React components');
 
   // ═══════════════════════════════════════════════════════════════════════
   // SUCCESS!
   // ═══════════════════════════════════════════════════════════════════════
 
-  console.log('\n' + '═'.repeat(50));
-  console.log('✨ Project created successfully!');
-  console.log('═'.repeat(50));
-  console.log(`\n📁 Project location: ${projectPath}`);
-  console.log('\n🎯 Next steps:');
-  console.log(`   cd ${projectName}`);
-  console.log('   npm run dev\n');
-  console.log('📚 Documentation: https://docs.husar.ai');
-  console.log('💬 Need help? Join our Discord: https://discord.gg/husar\n');
+  successBox(
+    `Project created at ${theme.info(projectPath)}\n\n` +
+      `Framework: ${theme.muted(framework)}\n` +
+      `CMS Host: ${theme.muted(project.host)}`,
+    'Project Ready!',
+  );
+
+  nextSteps([
+    `cd ${chalk.cyan(projectName)}`,
+    `${chalk.cyan('npm run dev')} to start development`,
+    `Open ${theme.link('https://docs.husar.ai')} for documentation`,
+  ]);
+
+  process.exit(0);
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
 // PROMPTS
 // ═══════════════════════════════════════════════════════════════════════════
 
-/**
- * Prompt for connection method
- */
-async function promptConnectionMethod(): Promise<'manual' | 'cloud'> {
-  console.log('How do you want to connect to your CMS?\n');
-  console.log('  1. Enter project URL manually');
-  console.log('  2. Login to husar.ai and select from list\n');
-
-  const choice = await promptChoice(2);
-  return choice === 1 ? 'manual' : 'cloud';
-}
-
-/**
- * Prompt for manual URL entry
- */
-async function promptManualUrl(): Promise<string> {
-  return new Promise((resolve) => {
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-    });
-
-    const ask = () => {
-      rl.question('\n🌐 Enter your CMS panel URL: ', (answer) => {
-        const url = answer.trim();
-
-        // Basic validation
-        if (!url) {
-          console.log('   URL is required.');
-          ask();
-          return;
-        }
-
-        if (!url.startsWith('http://') && !url.startsWith('https://')) {
-          console.log('   URL must start with http:// or https://');
-          ask();
-          return;
-        }
-
-        rl.close();
-        resolve(url);
-      });
-    };
-
-    ask();
-  });
-}
-
 /**
  * Prompt for project selection from list
  */
 async function promptSelectProject(projects: CloudProject[]): Promise<CloudProject> {
-  console.log('Select a project:\n');
-  projects.forEach((p, i) => {
-    console.log(`  ${i + 1}. ${p.name}`);
-    console.log(`     ${p.adminURL}\n`);
-  });
-
-  const choice = await promptChoice(projects.length);
-  return projects[choice - 1]!;
-}
-
-/**
- * Prompt for project directory name
- */
-async function promptProjectName(suggestedName?: string): Promise<string> {
-  return new Promise((resolve) => {
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-    });
-
-    const defaultName = suggestedName ? suggestedName.replace(/[^a-zA-Z0-9-_]/g, '-') : '';
-    const prompt = defaultName
-      ? `📝 Enter project directory name [${defaultName}]: `
-      : '📝 Enter project directory name: ';
-
-    rl.question(prompt, (answer) => {
-      rl.close();
-      const name = answer.trim() || defaultName;
-      resolve(name);
-    });
-  });
-}
-
-/**
- * Prompt for numeric choice
- */
-async function promptChoice(max: number): Promise<number> {
-  return new Promise((resolvePrompt) => {
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-    });
-
-    const ask = () => {
-      rl.question(`Enter choice (1-${max}): `, (answer) => {
-        const num = parseInt(answer, 10);
-        if (num >= 1 && num <= max) {
-          rl.close();
-          resolvePrompt(num);
-        } else {
-          console.log(`Please enter a number between 1 and ${max}`);
-          ask();
-        }
-      });
-    };
-    ask();
-  });
+  const choice = await select<string>(
+    'Select a project',
+    projects.map((p) => ({
+      name: p.name,
+      message: p.name,
+      hint: p.adminURL,
+    })),
+  );
+
+  return projects.find((p) => p.name === choice)!;
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -279,23 +271,25 @@ async function ensureCloudLogin(): Promise<{ accessToken: string; email?: string
 
   if (existingAuth) {
     // Verify the token is still valid
-    console.log('🔍 Checking existing cloud session...');
+    const spin = spinner('Checking existing session...');
     const isValid = await verifyAccessToken(existingAuth.accessToken);
 
     if (isValid) {
-      console.log(`✅ Logged in as: ${existingAuth.email ?? 'user'}`);
+      spin.succeed(`Logged in as ${theme.info(existingAuth.email ?? 'user')}`);
       return existingAuth;
     }
 
-    console.log('⚠️  Session expired, need to re-authenticate...');
+    spin.warn('Session expired, need to re-authenticate');
   }
 
   // Need to login
-  console.log('\n🔐 Please log in to Husar.ai...\n');
+  log.info('Please log in to Husar.ai...');
+  log.blank();
+
   const result = await startCloudLoginFlow();
 
   if (result.success && result.accessToken) {
-    console.log(`\n✅ Logged in as: ${result.email ?? 'user'}`);
+    log.success(`Logged in as ${theme.info(result.email ?? 'user')}`);
     return {
       accessToken: result.accessToken,
       email: result.email,
@@ -309,11 +303,63 @@ async function ensureCloudLogin(): Promise<{ accessToken: string; email?: string
 // FRAMEWORK CLI
 // ═══════════════════════════════════════════════════════════════════════════
 
+/**
+ * Initialize a clean project (npm init only)
+ */
+async function initCleanProject(projectName: string): Promise<boolean> {
+  const projectPath = resolve(process.cwd(), projectName);
+
+  return new Promise((done) => {
+    // Create directory
+    const mkdirChild = spawn('mkdir', ['-p', projectName], {
+      stdio: 'pipe',
+      shell: true,
+    });
+
+    mkdirChild.on('close', (mkdirCode) => {
+      if (mkdirCode !== 0) {
+        done(false);
+        return;
+      }
+
+      // Run npm init -y
+      const initChild = spawn('npm', ['init', '-y'], {
+        cwd: projectPath,
+        stdio: 'pipe',
+        shell: true,
+      });
+
+      initChild.on('close', async (initCode: number | null) => {
+        if (initCode !== 0) {
+          done(false);
+          return;
+        }
+
+        // Create src directory
+        try {
+          await fs.mkdir(join(projectPath, 'src'), { recursive: true });
+          done(true);
+        } catch {
+          done(false);
+        }
+      });
+
+      initChild.on('error', () => {
+        done(false);
+      });
+    });
+
+    mkdirChild.on('error', () => {
+      done(false);
+    });
+  });
+}
+
 /**
  * Run the framework-specific CLI
  */
 async function runFrameworkCli(framework: 'nextjs' | 'vite', projectName: string): Promise<boolean> {
-  return new Promise((resolve) => {
+  return new Promise((resolvePromise) => {
     let command: string;
     let args: string[];
 
@@ -337,7 +383,8 @@ async function runFrameworkCli(framework: 'nextjs' | 'vite', projectName: string
       args = ['create', 'vite@latest', projectName, '--', '--template', 'react-ts'];
     }
 
-    console.log(`Running: ${command} ${args.join(' ')}\n`);
+    log.dim(`Running: ${command} ${args.join(' ')}`);
+    log.blank();
 
     const child = spawn(command, args, {
       stdio: 'inherit',
@@ -345,12 +392,11 @@ async function runFrameworkCli(framework: 'nextjs' | 'vite', projectName: string
     });
 
     child.on('close', (code) => {
-      resolve(code === 0);
+      resolvePromise(code === 0);
     });
 
-    child.on('error', (err) => {
-      console.error('Failed to start framework CLI:', err.message);
-      resolve(false);
+    child.on('error', () => {
+      resolvePromise(false);
     });
   });
 }
@@ -359,23 +405,153 @@ async function runFrameworkCli(framework: 'nextjs' | 'vite', projectName: string
 // CONFIGURATION
 // ═══════════════════════════════════════════════════════════════════════════
 
+/**
+ * MCP command template for .opencode/command/husar.md
+ */
+const HUSAR_COMMAND_TEMPLATE = `# /husar - Husar.ai CMS Operations
+
+Use the **husar.ai** MCP server (configured in \`opencode.jsonc\`) for all CMS operations.
+
+## Available MCP Tools
+
+### Discovery & Schema
+
+- \`listModels\` — List all model definitions with their field structures
+- \`listViews\` — List all view definitions with their field structures
+- \`listShapes\` — List all shape definitions
+- \`graphQLTypes\` — Get the generated GraphQL SDL schema (understand exact input/output types)
+- \`rootParams\` — Get root parameters (e.g. available \`_language\` options)
+- \`links\` — List internal links
+
+### Shape Inspection
+
+- \`shape.getWithDefinition\` — Get complete shape info including definition, fieldSet, and GraphQL types
+- \`shape.model\` — Get full shape configuration
+- \`shape.previewFields\` — Get expanded fields for a shape
+- \`shape.fieldSet\` — Get admin page fieldset for a shape
+
+### Model Operations
+
+- \`model.getWithContent\` — **Use before upsert** to understand exact structure and get current content
+- \`model.list\` — List all documents for a model
+- \`model.one\` — Get a single document by slug
+- \`model.upsert\` — Create or update a model document (provide slug + args matching field definitions)
+- \`model.remove\` — Remove a document by slug
+
+### View Operations (singletons)
+
+- \`view.getWithContent\` — **Use before upsert** to understand exact structure and get current content
+- \`view.one\` — Get view content
+- \`view.upsert\` — Create or update view content
+- \`view.remove\` — Remove a view entry
+
+### Definition Management
+
+- \`upsertModel\` / \`removeModel\` — Manage model definitions (schema)
+- \`upsertView\` / \`removeView\` — Manage view definitions (schema)
+- \`upsertShape\` / \`removeShape\` — Manage shape definitions (schema)
+- \`removeModelWithDocuments\` — Remove a model and all its documents
+
+### Styling
+
+- \`style.tailwind.css.get\` — Fetch current Tailwind CSS source and compiled variants
+- \`style.tailwind.css.set\` — Set Tailwind CSS source content (Tailwind v4 compiles it after save)
+
+### AI Generation
+
+- \`generateContent\` — Generate content using AI
+- \`generateImage\` — Generate an image using AI
+- \`translateDocument\` — Translate a model document to another language
+- \`translateView\` — Translate a view to another language
+
+### Links
+
+- \`upsertLink\` — Create or update an internal link
+- \`removeLink\` — Remove an internal link
+
+### Files
+
+- \`uploadFile\` — Get a signed S3 PUT URL for uploading a file
+
+## Workflow Guidelines
+
+1. **Always call \`getWithContent\` before any upsert** — This gives you the exact field structure and current data so you can construct valid input.
+2. **Use \`graphQLTypes\`** when you need to understand the precise GraphQL input/output types expected by upsert operations.
+3. **Use \`listModels\` / \`listViews\` / \`listShapes\`** for discovery — find out what content types exist before operating on them.
+4. **For SHAPE fields**, provide nested objects matching the shape's field structure.
+5. **For RELATION fields**, provide \`_id\` strings.
+6. **Root params** (like \`_language\`) can be passed as a \`filter\` parameter to scope operations by locale.
+7. **Tailwind styles** are managed through the CMS — fetch with \`style.tailwind.css.get\` and update with \`style.tailwind.css.set\`.
+8. **Draft versions** can be saved by setting \`draft_version: true\` on upsert calls.
+
+## Example Workflows
+
+### Update view content
+
+\`\`\`
+1. view.getWithContent (understand structure + current data)
+2. view.upsert (provide updated args)
+\`\`\`
+
+### Create a new model document
+
+\`\`\`
+1. model.getWithContent (understand field structure)
+2. model.upsert (provide slug + args)
+\`\`\`
+
+### Modify CMS schema
+
+\`\`\`
+1. listModels / listViews / listShapes (see what exists)
+2. graphQLTypes (understand current schema)
+3. upsertModel / upsertView / upsertShape (modify definitions)
+\`\`\`
+
+### Update Tailwind styles
+
+\`\`\`
+1. style.tailwind.css.get (see current styles)
+2. style.tailwind.css.set (update with new content)
+\`\`\`
+`;
+
+/**
+ * Create .opencode/command/husar.md with MCP documentation
+ */
+async function createOpencodeCommandFolder(projectPath: string): Promise<void> {
+  const commandDir = join(projectPath, '.opencode', 'command');
+
+  try {
+    await fs.mkdir(commandDir, { recursive: true });
+    await fs.writeFile(join(commandDir, 'husar.md'), HUSAR_COMMAND_TEMPLATE);
+  } catch {
+    // Silent fail - not critical
+  }
+}
+
 /**
  * Add Husar configuration files to the project
  * Uses HYBRID storage: husar.json (committal) + .env.local (secrets)
  */
-async function addHusarConfig(projectPath: string, project: ProjectAuth, framework: 'nextjs' | 'vite'): Promise<void> {
-  const hostEnvVar = framework === 'nextjs' ? 'NEXT_PUBLIC_HUSAR_HOST' : 'VITE_HUSAR_HOST';
+async function addHusarConfig(
+  projectPath: string,
+  project: ProjectAuth,
+  framework: 'nextjs' | 'vite' | 'clean',
+): Promise<void> {
+  // Use appropriate env var prefix based on framework
+  const hostEnvVar =
+    framework === 'nextjs' ? 'NEXT_PUBLIC_HUSAR_HOST' : framework === 'vite' ? 'VITE_HUSAR_HOST' : 'HUSAR_HOST';
 
   // 1. Create husar.json (committal - NO adminToken!)
   const husarConfig = {
     host: project.host,
     hostEnvironmentVariable: hostEnvVar,
     authenticationEnvironmentVariable: 'HUSAR_API_KEY',
-    adminTokenEnv: 'HUSAR_ADMIN_TOKEN', // Points to env var, not actual token
+    adminTokenEnv: 'HUSAR_ADMIN_TOKEN',
     overrideHost: false,
   };
   await fs.writeFile(join(projectPath, 'husar.json'), JSON.stringify(husarConfig, null, 2));
-  console.log('   ✓ Created husar.json');
 
   // 2. Create .env.local (secrets - NOT committed)
   const envContent = `# Husar CMS Configuration
@@ -391,7 +567,6 @@ HUSAR_API_KEY=
 HUSAR_ADMIN_TOKEN=${project.adminToken}
 `;
   await fs.writeFile(join(projectPath, '.env.local'), envContent);
-  console.log('   ✓ Created .env.local (contains admin credentials)');
 
   // 3. Create opencode.jsonc for MCP integration
   const opencodeConfig = {
@@ -405,9 +580,11 @@ HUSAR_ADMIN_TOKEN=${project.adminToken}
     },
   };
   await fs.writeFile(join(projectPath, 'opencode.jsonc'), JSON.stringify(opencodeConfig, null, 2));
-  console.log('   ✓ Created opencode.jsonc (MCP configuration)');
 
-  // 4. Update .gitignore
+  // 4. Create .opencode/command/husar.md (MCP command documentation)
+  await createOpencodeCommandFolder(projectPath);
+
+  // 5. Update .gitignore
   const gitignorePath = join(projectPath, '.gitignore');
   try {
     let gitignore = await fs.readFile(gitignorePath, 'utf-8');
@@ -423,12 +600,10 @@ HUSAR_ADMIN_TOKEN=${project.adminToken}
     if (additions.length > 0) {
       gitignore += '\n# Local environment files (contain secrets)\n' + additions.join('\n') + '\n';
       await fs.writeFile(gitignorePath, gitignore);
-      console.log('   ✓ Updated .gitignore');
     }
   } catch {
     // .gitignore doesn't exist, create it
     await fs.writeFile(gitignorePath, '# Local environment files (contain secrets)\n.env.local\n.env*.local\n');
-    console.log('   ✓ Created .gitignore');
   }
 }
 
@@ -436,24 +611,21 @@ HUSAR_ADMIN_TOKEN=${project.adminToken}
  * Install Husar packages
  */
 async function installHusarPackages(projectPath: string): Promise<void> {
-  return new Promise((resolve) => {
+  return new Promise((resolvePromise) => {
     const packages = ['@husar.ai/ssr', '@husar.ai/render'];
 
     const child = spawn('npm', ['install', ...packages], {
       cwd: projectPath,
-      stdio: 'inherit',
+      stdio: 'pipe',
       shell: true,
     });
 
     child.on('close', () => {
-      console.log('   ✓ Installed @husar.ai/ssr and @husar.ai/render');
-      resolve();
+      resolvePromise();
     });
 
-    child.on('error', (err) => {
-      console.error('Warning: Failed to install packages:', err.message);
-      console.log('   Run manually: npm install @husar.ai/ssr @husar.ai/render');
-      resolve();
+    child.on('error', () => {
+      resolvePromise();
     });
   });
 }
@@ -461,29 +633,23 @@ async function installHusarPackages(projectPath: string): Promise<void> {
 /**
  * Generate CMS client files using husar generate
  */
-async function generateCmsClient(projectPath: string, framework: 'nextjs' | 'vite'): Promise<void> {
-  // Determine src folder based on framework
-  const srcFolder = framework === 'nextjs' ? './src' : './src';
+async function generateCmsClient(projectPath: string, framework: 'nextjs' | 'vite' | 'clean'): Promise<void> {
+  // All frameworks use ./src
+  const srcFolder = './src';
 
-  return new Promise((resolve) => {
+  return new Promise((resolvePromise) => {
     const child = spawn('npx', ['@husar.ai/cli', 'generate', srcFolder], {
       cwd: projectPath,
-      stdio: 'inherit',
+      stdio: 'pipe',
       shell: true,
     });
 
-    child.on('close', (code) => {
-      if (code === 0) {
-        console.log('   ✓ Generated cms/ folder with Zeus client');
-      } else {
-        console.log('   ⚠ CMS generation may have failed - you can run "husar generate" later');
-      }
-      resolve();
+    child.on('close', () => {
+      resolvePromise();
     });
 
     child.on('error', () => {
-      console.log('   ⚠ Could not generate CMS client - run "husar generate" manually');
-      resolve();
+      resolvePromise();
     });
   });
 }