create-loadout 1.0.0

package/dist/cli.js

@@ -0,0 +1,186 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import fs from 'fs/promises';
+import path from 'path';
+import { getProjectConfig, getAddIntegrationConfig } from './prompts.js';
+import { createNextApp } from './create-next.js';
+import { setupShadcn } from './setup-shadcn.js';
+import { installIntegrations } from './integrations/index.js';
+import { generateClaudeMd, appendClaudeMd } from './claude-md.js';
+import { generateEnvFiles, appendEnvFiles } from './env.js';
+import { generateConfig, appendConfig } from './config.js';
+import { generateReadme, generateGitignore } from './generate-readme.js';
+import { generateInstrumentationClient, generateInstrumentation, } from './instrumentation.js';
+import { zustandTemplates } from './templates/zustand.js';
+import { generateLandingPage } from './landing-page.js';
+import { isExistingProject, getInstalledIntegrations, getAvailableIntegrations, } from './detect.js';
+export async function main() {
+    console.log();
+    console.log(chalk.bold.cyan('  create-loadout'));
+    console.log(chalk.gray('  Custom Next.js scaffolding with SaaS integrations'));
+    console.log();
+    const cwd = process.cwd();
+    try {
+        if (await isExistingProject(cwd)) {
+            await addIntegrationFlow(cwd);
+        }
+        else {
+            await newProjectFlow();
+        }
+    }
+    catch (error) {
+        console.error();
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}
+async function newProjectFlow() {
+    const config = await getProjectConfig();
+    console.log();
+    const spinner = ora('Creating Next.js app...').start();
+    const projectPath = await createNextApp(config.name);
+    spinner.succeed('Next.js app created');
+    spinner.start('Setting up shadcn/ui...');
+    await setupShadcn(projectPath);
+    spinner.succeed('shadcn/ui configured');
+    await extendUtils(projectPath);
+    spinner.start('Installing base packages...');
+    const { execa } = await import('execa');
+    await execa('npm', ['install', 'zod@^3.24', 'zustand@^5', 'luxon@^3'], { cwd: projectPath });
+    await execa('npm', ['install', '-D', '@types/luxon'], { cwd: projectPath });
+    spinner.succeed('Base packages installed (zod, zustand, luxon)');
+    await fs.mkdir(path.join(projectPath, 'lib/stores'), { recursive: true });
+    await fs.writeFile(path.join(projectPath, 'lib/stores/counter.store.ts'), zustandTemplates.exampleStore);
+    if (config.integrations.length > 0) {
+        spinner.start(`Setting up ${config.integrations.length} integration(s)...`);
+        await installIntegrations(projectPath, config);
+        spinner.succeed('Integrations configured');
+    }
+    await generateInstrumentationClient(projectPath, config);
+    await generateInstrumentation(projectPath, config);
+    spinner.start('Generating config and environment files...');
+    await generateConfig(projectPath, config);
+    await generateEnvFiles(projectPath, config);
+    spinner.succeed('Config and environment files created');
+    spinner.start('Generating project files...');
+    await generateLandingPage(projectPath, config);
+    await generateGitignore(projectPath);
+    await generateReadme(projectPath, config);
+    await generateClaudeMd(projectPath, config);
+    spinner.succeed('Project files created');
+    console.log();
+    console.log(chalk.green.bold('  Success!') + ' Created ' + chalk.cyan(config.name));
+    console.log();
+    if (config.integrations.length > 0) {
+        console.log(chalk.bold('  Installed integrations:'));
+        config.integrations.forEach((integration) => {
+            console.log(chalk.gray(`    - ${integration}`));
+        });
+        console.log();
+    }
+    console.log(chalk.bold('  Next steps:'));
+    console.log(chalk.gray(`    1. cd ${config.name}`));
+    console.log(chalk.gray('    2. Configure .env.local with your API keys'));
+    console.log(chalk.gray('    3. npm run dev'));
+    console.log();
+    if (config.integrations.includes('neon-drizzle')) {
+        console.log(chalk.yellow('  Database commands:'));
+        console.log(chalk.gray('    npm run db:generate  - Generate migrations'));
+        console.log(chalk.gray('    npm run db:migrate   - Run migrations'));
+        console.log(chalk.gray('    npm run db:studio    - Open Drizzle Studio'));
+        console.log();
+    }
+    if (config.integrations.includes('inngest')) {
+        console.log(chalk.yellow('  Inngest commands:'));
+        console.log(chalk.gray('    npm run inngest:dev  - Start Inngest dev server'));
+        console.log();
+    }
+}
+async function addIntegrationFlow(projectPath) {
+    console.log(chalk.yellow('  Existing Next.js project detected'));
+    console.log(chalk.gray('  Running in add integration mode'));
+    console.log();
+    const installed = await getInstalledIntegrations(projectPath);
+    const available = getAvailableIntegrations(installed);
+    if (available.length === 0) {
+        console.log(chalk.green('  All integrations already installed!'));
+        return;
+    }
+    if (installed.length > 0) {
+        console.log(chalk.gray('  Already installed: ') + installed.join(', '));
+        console.log();
+    }
+    const addConfig = await getAddIntegrationConfig(available);
+    if (addConfig.integrations.length === 0) {
+        console.log();
+        console.log(chalk.gray('  No integrations selected'));
+        return;
+    }
+    console.log();
+    const spinner = ora(`Installing ${addConfig.integrations.length} integration(s)...`).start();
+    const config = {
+        name: path.basename(projectPath),
+        integrations: addConfig.integrations,
+        aiProvider: addConfig.aiProvider,
+    };
+    await installIntegrations(projectPath, config);
+    spinner.succeed('Integrations installed');
+    spinner.start('Updating config and environment files...');
+    await appendConfig(projectPath, addConfig.integrations, addConfig.aiProvider);
+    await appendEnvFiles(projectPath, addConfig.integrations, addConfig.aiProvider);
+    spinner.succeed('Config and environment files updated');
+    spinner.start('Updating CLAUDE.md...');
+    await appendClaudeMd(projectPath, addConfig.integrations);
+    spinner.succeed('CLAUDE.md updated');
+    console.log();
+    console.log(chalk.green.bold('  Success!') + ' Added integrations:');
+    addConfig.integrations.forEach((integration) => {
+        console.log(chalk.gray(`    - ${integration}`));
+    });
+    console.log();
+    console.log(chalk.bold('  Next steps:'));
+    console.log(chalk.gray('    1. Update .env.local with new API keys'));
+    console.log(chalk.gray('    2. npm run dev'));
+    console.log();
+    if (addConfig.integrations.includes('neon-drizzle')) {
+        console.log(chalk.yellow('  Database commands:'));
+        console.log(chalk.gray('    npm run db:generate  - Generate migrations'));
+        console.log(chalk.gray('    npm run db:migrate   - Run migrations'));
+        console.log(chalk.gray('    npm run db:studio    - Open Drizzle Studio'));
+        console.log();
+    }
+    if (addConfig.integrations.includes('inngest')) {
+        console.log(chalk.yellow('  Inngest commands:'));
+        console.log(chalk.gray('    npm run inngest:dev  - Start Inngest dev server'));
+        console.log();
+    }
+}
+async function extendUtils(projectPath) {
+    const utilsPath = path.join(projectPath, 'lib/utils.ts');
+    const existingContent = await fs.readFile(utilsPath, 'utf-8');
+    const additionalUtils = `
+import { DateTime } from 'luxon';
+
+export function formatDate(date: Date | string, format = 'LLL d, yyyy'): string {
+  const dt = typeof date === 'string' ? DateTime.fromISO(date) : DateTime.fromJSDate(date);
+  return dt.toFormat(format);
+}
+
+export function formatRelative(date: Date | string): string {
+  const dt = typeof date === 'string' ? DateTime.fromISO(date) : DateTime.fromJSDate(date);
+  return dt.toRelative() ?? dt.toFormat('LLL d, yyyy');
+}
+
+export function debounce<P extends unknown[], R>(
+  func: (...args: P) => R,
+  wait: number
+): (...args: P) => void {
+  let timeout: ReturnType<typeof setTimeout>;
+  return (...args: P) => {
+    clearTimeout(timeout);
+    timeout = setTimeout(() => func(...args), wait);
+  };
+}
+`;
+    await fs.writeFile(utilsPath, existingContent + additionalUtils);
+}

package/dist/config.d.ts

@@ -0,0 +1,3 @@
+import type { IntegrationId, ProjectConfig, AIProviderChoice } from './types.js';
+export declare function generateConfig(projectPath: string, config: ProjectConfig): Promise<void>;
+export declare function appendConfig(projectPath: string, integrations: IntegrationId[], aiProvider?: AIProviderChoice): Promise<void>;

package/dist/config.js

@@ -0,0 +1,98 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { getAiConfigVar } from './templates/ai-sdk.js';
+const staticConfigVars = {
+    core: [],
+    clerk: [
+        { name: 'CLERK_PUBLISHABLE_KEY', envKey: 'NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY', isPublic: true },
+        { name: 'CLERK_SECRET_KEY', envKey: 'CLERK_SECRET_KEY', isPublic: false },
+    ],
+    'neon-drizzle': [
+        { name: 'DATABASE_URL', envKey: 'DATABASE_URL', isPublic: false },
+    ],
+    resend: [
+        { name: 'RESEND_API_KEY', envKey: 'RESEND_API_KEY', isPublic: false },
+        { name: 'RESEND_FROM_EMAIL', envKey: 'RESEND_FROM_EMAIL', isPublic: false, defaultValue: 'onboarding@resend.dev' },
+    ],
+    firecrawl: [
+        { name: 'FIRECRAWL_API_KEY', envKey: 'FIRECRAWL_API_KEY', isPublic: false },
+    ],
+    inngest: [
+        { name: 'INNGEST_EVENT_KEY', envKey: 'INNGEST_EVENT_KEY', isPublic: false },
+        { name: 'INNGEST_SIGNING_KEY', envKey: 'INNGEST_SIGNING_KEY', isPublic: false },
+    ],
+    uploadthing: [
+        { name: 'UPLOADTHING_TOKEN', envKey: 'UPLOADTHING_TOKEN', isPublic: false },
+    ],
+    stripe: [
+        { name: 'STRIPE_SECRET_KEY', envKey: 'STRIPE_SECRET_KEY', isPublic: false },
+        { name: 'STRIPE_PUBLISHABLE_KEY', envKey: 'NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY', isPublic: true },
+        { name: 'STRIPE_WEBHOOK_SECRET', envKey: 'STRIPE_WEBHOOK_SECRET', isPublic: false },
+    ],
+    posthog: [
+        { name: 'POSTHOG_KEY', envKey: 'NEXT_PUBLIC_POSTHOG_KEY', isPublic: true },
+        { name: 'POSTHOG_HOST', envKey: 'NEXT_PUBLIC_POSTHOG_HOST', isPublic: true, defaultValue: 'https://us.i.posthog.com' },
+    ],
+    sentry: [
+        { name: 'SENTRY_DSN', envKey: 'NEXT_PUBLIC_SENTRY_DSN', isPublic: true },
+        { name: 'SENTRY_AUTH_TOKEN', envKey: 'SENTRY_AUTH_TOKEN', isPublic: false },
+        { name: 'SENTRY_ORG', envKey: 'SENTRY_ORG', isPublic: false },
+        { name: 'SENTRY_PROJECT', envKey: 'SENTRY_PROJECT', isPublic: false },
+    ],
+};
+function getConfigVars(id, aiProvider) {
+    if (id === 'ai-sdk') {
+        const aiVar = getAiConfigVar(aiProvider ?? 'openai');
+        return [{ name: aiVar.name, envKey: aiVar.envKey, isPublic: false }];
+    }
+    return staticConfigVars[id] ?? [];
+}
+export async function generateConfig(projectPath, config) {
+    const selectedIds = ['core', ...config.integrations];
+    let content = '';
+    for (const id of selectedIds) {
+        const vars = getConfigVars(id, config.aiProvider);
+        if (!vars || vars.length === 0)
+            continue;
+        for (const v of vars) {
+            if (v.defaultValue) {
+                content += `export const ${v.name} = process.env.${v.envKey} ?? '${v.defaultValue}';\n`;
+            }
+            else {
+                content += `export const ${v.name} = process.env.${v.envKey} as string;\n`;
+            }
+        }
+        content += '\n';
+    }
+    await fs.mkdir(path.join(projectPath, 'lib'), { recursive: true });
+    await fs.writeFile(path.join(projectPath, 'lib/config.ts'), content.trim() + '\n');
+}
+export async function appendConfig(projectPath, integrations, aiProvider) {
+    const configPath = path.join(projectPath, 'lib/config.ts');
+    let existing = '';
+    try {
+        existing = await fs.readFile(configPath, 'utf-8');
+    }
+    catch {
+        existing = '';
+    }
+    let content = '';
+    for (const id of integrations) {
+        const vars = getConfigVars(id, aiProvider);
+        if (!vars || vars.length === 0)
+            continue;
+        for (const v of vars) {
+            if (v.defaultValue) {
+                content += `export const ${v.name} = process.env.${v.envKey} ?? '${v.defaultValue}';\n`;
+            }
+            else {
+                content += `export const ${v.name} = process.env.${v.envKey} as string;\n`;
+            }
+        }
+        content += '\n';
+    }
+    if (content) {
+        const newContent = existing.trimEnd() + '\n\n' + content.trim() + '\n';
+        await fs.writeFile(configPath, newContent);
+    }
+}

package/dist/create-next.d.ts

@@ -0,0 +1 @@
+export declare function createNextApp(name: string): Promise<string>;

package/dist/create-next.js

@@ -0,0 +1,17 @@
+import { execa } from 'execa';
+import path from 'path';
+export async function createNextApp(name) {
+    await execa('npx', [
+        'create-next-app@latest',
+        name,
+        '--typescript',
+        '--tailwind',
+        '--eslint',
+        '--app',
+        '--import-alias', '@/*',
+        '--yes',
+    ], {
+        stdio: 'inherit',
+    });
+    return path.resolve(process.cwd(), name);
+}

package/dist/detect.d.ts

@@ -0,0 +1,4 @@
+import type { IntegrationId } from './types.js';
+export declare function isExistingProject(cwd: string): Promise<boolean>;
+export declare function getInstalledIntegrations(cwd: string): Promise<IntegrationId[]>;
+export declare function getAvailableIntegrations(installed: IntegrationId[]): IntegrationId[];

package/dist/detect.js

@@ -0,0 +1,60 @@
+import fs from 'fs/promises';
+import path from 'path';
+const integrationPackages = {
+    clerk: ['@clerk/nextjs'],
+    'neon-drizzle': ['drizzle-orm', '@neondatabase/serverless'],
+    'ai-sdk': ['ai'],
+    resend: ['resend'],
+    firecrawl: ['@mendable/firecrawl-js'],
+    inngest: ['inngest'],
+    uploadthing: ['uploadthing'],
+    stripe: ['stripe'],
+    posthog: ['posthog-js'],
+    sentry: ['@sentry/nextjs'],
+};
+export async function isExistingProject(cwd) {
+    try {
+        const pkgPath = path.join(cwd, 'package.json');
+        const content = await fs.readFile(pkgPath, 'utf-8');
+        const pkg = JSON.parse(content);
+        const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+        return 'next' in allDeps;
+    }
+    catch {
+        return false;
+    }
+}
+export async function getInstalledIntegrations(cwd) {
+    try {
+        const pkgPath = path.join(cwd, 'package.json');
+        const content = await fs.readFile(pkgPath, 'utf-8');
+        const pkg = JSON.parse(content);
+        const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+        const installed = [];
+        for (const [integrationId, packages] of Object.entries(integrationPackages)) {
+            const hasAll = packages.every((pkg) => pkg in allDeps);
+            if (hasAll) {
+                installed.push(integrationId);
+            }
+        }
+        return installed;
+    }
+    catch {
+        return [];
+    }
+}
+export function getAvailableIntegrations(installed) {
+    const all = [
+        'clerk',
+        'neon-drizzle',
+        'ai-sdk',
+        'resend',
+        'firecrawl',
+        'inngest',
+        'uploadthing',
+        'stripe',
+        'posthog',
+        'sentry',
+    ];
+    return all.filter((id) => !installed.includes(id));
+}

package/dist/env.d.ts

@@ -0,0 +1,3 @@
+import type { IntegrationId, ProjectConfig, AIProviderChoice } from './types.js';
+export declare function generateEnvFiles(projectPath: string, config: ProjectConfig): Promise<void>;
+export declare function appendEnvFiles(projectPath: string, integrations: IntegrationId[], aiProvider?: AIProviderChoice): Promise<void>;

package/dist/env.js

@@ -0,0 +1,183 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { getAiEnvVar } from './templates/ai-sdk.js';
+const staticEnvSections = {
+    core: {
+        name: 'CORE',
+        vars: [],
+    },
+    clerk: {
+        name: 'CLERK - Authentication',
+        url: 'https://dashboard.clerk.com',
+        vars: [
+            { key: 'NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY', example: 'pk_test_...', description: 'Clerk publishable key' },
+            { key: 'CLERK_SECRET_KEY', example: 'sk_test_...', description: 'Clerk secret key' },
+        ],
+    },
+    'neon-drizzle': {
+        name: 'NEON - Database',
+        url: 'https://console.neon.tech',
+        vars: [
+            { key: 'DATABASE_URL', example: 'postgresql://user:pass@host/db?sslmode=require', description: 'Neon database connection string' },
+        ],
+    },
+    resend: {
+        name: 'RESEND - Email',
+        url: 'https://resend.com/api-keys',
+        vars: [
+            { key: 'RESEND_API_KEY', example: 're_...', description: 'Resend API key' },
+            { key: 'RESEND_FROM_EMAIL', example: 'onboarding@resend.dev', description: 'Default from email address' },
+        ],
+    },
+    firecrawl: {
+        name: 'FIRECRAWL - Scraping',
+        url: 'https://firecrawl.dev',
+        vars: [
+            { key: 'FIRECRAWL_API_KEY', example: 'fc-...', description: 'Firecrawl API key' },
+        ],
+    },
+    inngest: {
+        name: 'INNGEST - Background Jobs',
+        url: 'https://app.inngest.com',
+        vars: [
+            { key: 'INNGEST_EVENT_KEY', example: '...', description: 'Inngest event key' },
+            { key: 'INNGEST_SIGNING_KEY', example: '...', description: 'Inngest signing key' },
+        ],
+    },
+    uploadthing: {
+        name: 'UPLOADTHING - File Uploads',
+        url: 'https://uploadthing.com/dashboard',
+        vars: [
+            { key: 'UPLOADTHING_TOKEN', example: '...', description: 'UploadThing token' },
+        ],
+    },
+    stripe: {
+        name: 'STRIPE - Payments',
+        url: 'https://dashboard.stripe.com/apikeys',
+        vars: [
+            { key: 'STRIPE_SECRET_KEY', example: 'sk_test_...', description: 'Stripe secret key' },
+            { key: 'NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY', example: 'pk_test_...', description: 'Stripe publishable key' },
+            { key: 'STRIPE_WEBHOOK_SECRET', example: 'whsec_...', description: 'Stripe webhook secret' },
+        ],
+    },
+    posthog: {
+        name: 'POSTHOG - Analytics',
+        url: 'https://app.posthog.com/project/settings',
+        vars: [
+            { key: 'NEXT_PUBLIC_POSTHOG_KEY', example: 'phc_...', description: 'PostHog project API key' },
+            { key: 'NEXT_PUBLIC_POSTHOG_HOST', example: 'https://us.i.posthog.com', description: 'PostHog host' },
+        ],
+    },
+    sentry: {
+        name: 'SENTRY - Error Tracking',
+        url: 'https://sentry.io/settings/projects',
+        vars: [
+            { key: 'NEXT_PUBLIC_SENTRY_DSN', example: 'https://...@sentry.io/...', description: 'Sentry DSN' },
+            { key: 'SENTRY_AUTH_TOKEN', example: 'sntrys_...', description: 'Sentry auth token for source maps' },
+            { key: 'SENTRY_ORG', example: 'your-org', description: 'Sentry organization slug' },
+            { key: 'SENTRY_PROJECT', example: 'your-project', description: 'Sentry project slug' },
+        ],
+    },
+};
+function getAiEnvSection(provider) {
+    const envVar = getAiEnvVar(provider);
+    const urls = {
+        openai: 'https://platform.openai.com/api-keys',
+        anthropic: 'https://console.anthropic.com/settings/keys',
+        google: 'https://aistudio.google.com/apikey',
+    };
+    const names = {
+        openai: 'OPENAI - AI',
+        anthropic: 'ANTHROPIC - AI',
+        google: 'GOOGLE - AI',
+    };
+    return {
+        name: names[provider],
+        url: urls[provider],
+        vars: [envVar],
+    };
+}
+function getEnvSection(id, aiProvider) {
+    if (id === 'ai-sdk') {
+        return getAiEnvSection(aiProvider ?? 'openai');
+    }
+    return staticEnvSections[id];
+}
+function generateEnvSection(section, includeExamples) {
+    let content = `# ===========================================\n`;
+    content += `# ${section.name}\n`;
+    if (section.url) {
+        content += `# Get keys at: ${section.url}\n`;
+    }
+    content += `# ===========================================\n`;
+    for (const v of section.vars) {
+        if (includeExamples) {
+            content += `${v.key}=${v.example}\n`;
+        }
+        else {
+            content += `${v.key}=\n`;
+        }
+    }
+    return content;
+}
+export async function generateEnvFiles(projectPath, config) {
+    const selectedIds = ['core', ...config.integrations];
+    // Generate .env.example with all vars and examples
+    let envExample = '';
+    for (const id of selectedIds) {
+        const section = getEnvSection(id, config.aiProvider);
+        envExample += generateEnvSection(section, true);
+        envExample += '\n';
+    }
+    await fs.writeFile(path.join(projectPath, '.env.example'), envExample.trim() + '\n');
+    // Generate .env.local with empty values
+    let envLocal = '';
+    for (const id of selectedIds) {
+        const section = getEnvSection(id, config.aiProvider);
+        envLocal += generateEnvSection(section, false);
+        envLocal += '\n';
+    }
+    await fs.writeFile(path.join(projectPath, '.env.local'), envLocal.trim() + '\n');
+    // Update .gitignore to include .env.local
+    const gitignorePath = path.join(projectPath, '.gitignore');
+    try {
+        let gitignore = await fs.readFile(gitignorePath, 'utf-8');
+        if (!gitignore.includes('.env.local')) {
+            gitignore += '\n# Environment variables\n.env.local\n.env*.local\n';
+            await fs.writeFile(gitignorePath, gitignore);
+        }
+    }
+    catch {
+        // .gitignore doesn't exist, create it
+        await fs.writeFile(gitignorePath, '# Environment variables\n.env.local\n.env*.local\n');
+    }
+}
+export async function appendEnvFiles(projectPath, integrations, aiProvider) {
+    const envExamplePath = path.join(projectPath, '.env.example');
+    const envLocalPath = path.join(projectPath, '.env.local');
+    let envExampleContent = '';
+    let envLocalContent = '';
+    for (const id of integrations) {
+        const section = getEnvSection(id, aiProvider);
+        envExampleContent += '\n' + generateEnvSection(section, true);
+        envLocalContent += '\n' + generateEnvSection(section, false);
+    }
+    if (envExampleContent) {
+        try {
+            const existing = await fs.readFile(envExamplePath, 'utf-8');
+            await fs.writeFile(envExamplePath, existing.trimEnd() + '\n' + envExampleContent.trim() + '\n');
+        }
+        catch {
+            await fs.writeFile(envExamplePath, envExampleContent.trim() + '\n');
+        }
+    }
+    if (envLocalContent) {
+        try {
+            const existing = await fs.readFile(envLocalPath, 'utf-8');
+            await fs.writeFile(envLocalPath, existing.trimEnd() + '\n' + envLocalContent.trim() + '\n');
+        }
+        catch {
+            await fs.writeFile(envLocalPath, envLocalContent.trim() + '\n');
+        }
+    }
+}

package/dist/generate-readme.d.ts

@@ -0,0 +1,3 @@
+import type { ProjectConfig } from './types.js';
+export declare function generateReadme(projectPath: string, config: ProjectConfig): Promise<void>;
+export declare function generateGitignore(projectPath: string): Promise<void>;