kaddidlehopper 0.5.0 → 0.7.0

package/dist/cli.js

@@ -1,11 +1,14 @@
-import { resolve, basename, join } from 'node:path';
-import { unlink } from 'node:fs/promises';
-import { Command, InvalidArgumentError } from 'commander';
+import { resolve, basename } from 'node:path';
+import { existsSync, readdirSync } from 'node:fs';
+import { cp, rm, mkdtemp, readFile, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+import { Command } from 'commander';
 import chalk from 'chalk';
 import validatePackageName from 'validate-npm-package-name';
-import { SUPPORTED_PACKAGE_MANAGERS, createApp, createDefaultEnvironment, finalizeAddOns, getAllAddOns, getFrameworkByName, getPackageManager, DEFAULT_PACKAGE_MANAGER, populateAddOnOptionsDefaults, } from '@tanstack/cta-engine';
-import { generateAgentsMd } from './agents-md.js';
-// Utility functions
+const GITHUB_REPO = 'https://github.com/netlify/swar-templates.git';
+const MANIFEST_URL = 'https://raw.githubusercontent.com/netlify/swar-templates/main/manifest.json';
 function sanitizePackageName(name) {
     return name
         .toLowerCase()
@@ -28,230 +31,144 @@ function validateProjectName(name) {
             'Project name does not meet npm package naming requirements',
     };
 }
-// Create environment with UI functions for console output
-function createEnvironment(appName) {
-    const env = createDefaultEnvironment();
-    env.appName = appName;
-    env.intro = (message) => console.log(chalk.bold.cyan(message));
-    env.outro = (message) => console.log(chalk.bold.green(message));
-    env.info = (title, message) => {
-        if (title && message) {
-            console.log(chalk.blue(`${title}: ${message}`));
-        }
-        else if (title) {
-            console.log(chalk.blue(title));
-        }
-    };
-    env.error = (title, message) => {
-        if (title && message) {
-            console.error(chalk.red(`${title}: ${message}`));
-        }
-        else if (title) {
-            console.error(chalk.red(title));
-        }
-    };
-    env.warn = (title, message) => {
-        if (title && message) {
-            console.warn(chalk.yellow(`${title}: ${message}`));
-        }
-        else if (title) {
-            console.warn(chalk.yellow(title));
-        }
-    };
-    env.spinner = () => ({
-        start: (message) => console.log(chalk.gray(`⟳ ${message}`)),
-        stop: (message) => console.log(chalk.green(`✓ ${message}`)),
-    });
-    return env;
+function getPackageManagerFromUserAgent() {
+    const userAgent = process.env.npm_config_user_agent;
+    if (!userAgent)
+        return undefined;
+    const pmSpec = userAgent.split(' ')[0];
+    const separatorPos = pmSpec.lastIndexOf('/');
+    return separatorPos !== -1 ? pmSpec.substring(0, separatorPos) : pmSpec;
 }
-export function cli({ name, appName, defaultFramework, forcedMode, forcedAddOns = [], }) {
-    const environment = createEnvironment(appName);
+export function cli() {
     const program = new Command();
-    const defaultMode = forcedMode || 'file-router';
-    program.name(name).description(`CLI to create a new ${appName} application`);
+    program
+        .name('netlify-cta')
+        .description('CLI to create a new Netlify TanStack Start application');
     program.argument('[project-name]', 'name of the project');
     program
         .option('--no-install', 'skip installing dependencies')
-        .option(`--package-manager <${SUPPORTED_PACKAGE_MANAGERS.join('|')}>`, `Explicitly tell the CLI to use this package manager`, (value) => {
-        if (!SUPPORTED_PACKAGE_MANAGERS.includes(value)) {
-            throw new InvalidArgumentError(`Invalid package manager: ${value}. The following are allowed: ${SUPPORTED_PACKAGE_MANAGERS.join(', ')}`);
-        }
-        return value;
-    })
-        .option('--add-ons [...add-ons]', 'pick from a list of available add-ons (comma separated list)', (value) => {
-        let addOns = !!value;
-        if (typeof value === 'string') {
-            addOns = value.split(',').map((addon) => addon.trim());
-        }
-        return addOns;
-    })
-        .option('--list-add-ons', 'list all available add-ons', false)
-        .option('--list-addons-json', 'list all available add-ons as JSON', false)
-        .option('--addon-details <addon-id>', 'show detailed information about a specific add-on')
+        .option('--package-manager <pm>', 'explicitly tell the CLI to use this package manager')
+        .option('--add-ons [id]', 'starter ID to use from the template repo')
+        .option('--list-addons-json', 'list all available starters as JSON', false)
         .option('--no-git', 'do not create a git repository')
-        .option('--target-dir <path>', 'the target directory for the application root', '.')
-        .option('-f, --force', 'force project creation even if the target directory is not empty', true)
-        .option('--no-force', 'refuse to create if the target directory is not empty')
-        .option('--bare-bones', 'create minimal scaffolding for LLM modification', true)
-        .option('--no-bare-bones', 'create full scaffolding (not minimal)');
+        .option('--target-dir <path>', 'the target directory for the application root')
+        .option('-f, --force', 'force project creation even if the target directory is not empty');
     program.action(async (projectName, options) => {
-        const framework = getFrameworkByName(defaultFramework);
-        if (!framework) {
-            console.error(`Framework '${defaultFramework}' not found`);
-            process.exit(1);
-        }
         // Handle --list-addons-json
         if (options.listAddonsJson) {
-            const addOns = await getAllAddOns(framework, defaultMode);
-            const serialized = addOns
-                .filter((a) => !forcedAddOns.includes(a.id))
-                .map((addon) => ({
-                id: addon.id,
-                name: addon.name,
-                description: addon.description,
-                type: addon.type,
-                features: addon.features ?? [],
-                options: addon.options,
-            }));
-            console.log(JSON.stringify(serialized, null, 2));
-            return;
+            const manifest = await fetch(MANIFEST_URL).then((r) => r.json());
+            console.log(JSON.stringify(manifest.starters, null, 2));
+            process.exit(0);
+        }
+        // Resolve starter ID
+        const starterId = typeof options.addOns === 'string' ? options.addOns : 'basic';
+        // Resolve target directory — default to CWD
+        const targetDir = options.targetDir ? resolve(options.targetDir) : resolve(process.cwd());
+        // Resolve project name for package.json
+        let resolvedProjectName;
+        if (projectName && projectName !== '.') {
+            resolvedProjectName = sanitizePackageName(projectName);
         }
-        // Handle --list-add-ons (text format)
-        if (options.listAddOns) {
-            const addOns = await getAllAddOns(framework, defaultMode);
-            let hasConfigurableAddOns = false;
-            for (const addOn of addOns.filter((a) => !forcedAddOns.includes(a.id))) {
-                const hasOptions = addOn.options && Object.keys(addOn.options).length > 0;
-                const optionMarker = hasOptions ? '*' : ' ';
-                if (hasOptions)
-                    hasConfigurableAddOns = true;
-                console.log(`${optionMarker} ${chalk.bold(addOn.id)}: ${addOn.description}`);
-            }
-            if (hasConfigurableAddOns) {
-                console.log('\n* = has configuration options');
-            }
-            return;
+        else {
+            resolvedProjectName = sanitizePackageName(getCurrentDirectoryName());
         }
-        // Handle --addon-details
-        if (options.addonDetails) {
-            const addOns = await getAllAddOns(framework, defaultMode);
-            const addOn = addOns.find((a) => a.id === options.addonDetails);
-            if (!addOn) {
-                console.error(`Add-on '${options.addonDetails}' not found`);
+        const { valid, error } = validateProjectName(resolvedProjectName);
+        if (!valid) {
+            console.error(chalk.red(error));
+            process.exit(1);
+        }
+        // Check if target directory exists and is non-empty
+        if (existsSync(targetDir)) {
+            const contents = readdirSync(targetDir);
+            if (contents.length > 0 && !options.force) {
+                console.error(chalk.red(`Target directory "${targetDir}" is not empty. Use --force to overwrite.`));
                 process.exit(1);
             }
-            console.log(`${chalk.bold.cyan('Add-on Details:')} ${chalk.bold(addOn.name)}`);
-            console.log(`${chalk.bold('ID:')} ${addOn.id}`);
-            console.log(`${chalk.bold('Description:')} ${addOn.description}`);
-            console.log(`${chalk.bold('Type:')} ${addOn.type}`);
-            console.log(`${chalk.bold('Phase:')} ${addOn.phase}`);
-            console.log(`${chalk.bold('Supported Modes:')} ${addOn.modes.join(', ')}`);
-            if (addOn.dependsOn && addOn.dependsOn.length > 0) {
-                console.log(`${chalk.bold('Dependencies:')} ${addOn.dependsOn.join(', ')}`);
+        }
+        // Delete index.html if it exists in the target directory
+        const indexHtmlPath = join(targetDir, 'index.html');
+        if (existsSync(indexHtmlPath)) {
+            await rm(indexHtmlPath);
+        }
+        console.log(chalk.bold.cyan(`Creating a new Netlify TanStack Start app in ${chalk.white(targetDir)}...`));
+        console.log(chalk.gray(`Using starter: ${starterId}`));
+        const manifest = await fetch(MANIFEST_URL).then((r) => r.json());
+        const starterEntry = manifest.starters.find((s) => s.id === starterId);
+        const frameworkId = starterEntry?.framework;
+        // Sparse clone the template repo into a temp directory
+        const tmpDir = await mkdtemp(join(tmpdir(), 'netlify-cta-'));
+        try {
+            console.log(chalk.gray('⟳ Fetching template...'));
+            const sparsePaths = [`starters/${starterId}`, ...(frameworkId ? [`frameworks/${frameworkId}`] : [])];
+            execSync(`git clone --depth=1 --filter=blob:none --sparse ${GITHUB_REPO} ${tmpDir}`, { stdio: 'pipe' });
+            execSync(`git -C ${tmpDir} sparse-checkout set ${sparsePaths.join(' ')}`, { stdio: 'pipe' });
+            const starterPath = join(tmpDir, 'starters', starterId);
+            if (!existsSync(starterPath)) {
+                console.error(chalk.red(`Starter "${starterId}" not found in the template repo. Run --list-addons-json to see available starters.`));
+                process.exit(1);
             }
-            if (addOn.options && Object.keys(addOn.options).length > 0) {
-                console.log(`\n${chalk.bold.yellow('Configuration Options:')}`);
-                for (const [optionName, option] of Object.entries(addOn.options)) {
-                    if (option && typeof option === 'object' && 'type' in option) {
-                        const opt = option;
-                        console.log(`  ${chalk.bold(optionName)}:`);
-                        console.log(`    Label: ${opt.label}`);
-                        if (opt.description) {
-                            console.log(`    Description: ${opt.description}`);
-                        }
-                        console.log(`    Type: ${opt.type}`);
-                        console.log(`    Default: ${opt.default}`);
-                        if (opt.type === 'select' && opt.options) {
-                            console.log(`    Available values:`);
-                            for (const choice of opt.options) {
-                                console.log(`      - ${choice.value}: ${choice.label}`);
-                            }
-                        }
-                    }
+            // Copy starter files to target directory
+            await cp(starterPath, targetDir, { recursive: true });
+            // Copy framework overlay files if they exist
+            if (frameworkId) {
+                const frameworkPath = join(tmpDir, 'frameworks', frameworkId);
+                if (existsSync(frameworkPath)) {
+                    console.log(chalk.gray(`⟳ Applying framework overlay (${frameworkId})...`));
+                    await cp(frameworkPath, targetDir, { recursive: true });
+                    console.log(chalk.green(`✓ Framework overlay applied (${frameworkId})`));
+                }
+                else {
+                    console.log(chalk.yellow(`⚠ Framework overlay "${frameworkId}" not found in repo, skipping`));
                 }
             }
-            else {
-                console.log(`\n${chalk.gray('No configuration options available')}`);
-            }
-            if (addOn.routes && addOn.routes.length > 0) {
-                console.log(`\n${chalk.bold.green('Routes:')}`);
-                for (const route of addOn.routes) {
-                    console.log(`  ${chalk.bold(route.url)} (${route.name})`);
-                    console.log(`    File: ${route.path}`);
+            // Update package.json name if a project name was provided
+            if (projectName && projectName !== '.') {
+                const pkgPath = join(targetDir, 'package.json');
+                if (existsSync(pkgPath)) {
+                    const pkg = JSON.parse(await readFile(pkgPath, 'utf-8'));
+                    pkg.name = resolvedProjectName;
+                    await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
                 }
             }
-            return;
-        }
-        // Handle project creation: target-dir defaults to current directory
-        const targetDir = resolve(options.targetDir ?? '.');
-        const isCurrentDir = targetDir === resolve(process.cwd());
-        let resolvedProjectName;
-        if (projectName) {
-            resolvedProjectName =
-                projectName === '.'
-                    ? sanitizePackageName(getCurrentDirectoryName())
-                    : sanitizePackageName(projectName);
-        }
-        else if (isCurrentDir) {
-            resolvedProjectName = sanitizePackageName(getCurrentDirectoryName());
-        }
-        else {
-            console.error('Project name is required when --target-dir is not the current directory');
-            program.help();
-            return;
+            console.log(chalk.green(`✓ Template copied`));
         }
-        const { valid, error } = validateProjectName(resolvedProjectName);
-        if (!valid) {
-            console.error(error);
-            process.exit(1);
+        finally {
+            await rm(tmpDir, { recursive: true, force: true });
         }
-        // Determine selected add-ons
-        const selectedAddOns = new Set([...forcedAddOns]);
-        if (options.addOns && Array.isArray(options.addOns)) {
-            for (const a of options.addOns) {
-                selectedAddOns.add(a);
+        // Initialize git repository
+        if (options.git !== false) {
+            try {
+                execSync('git init', { cwd: targetDir, stdio: 'pipe' });
+                console.log(chalk.green('✓ Initialized git repository'));
+            }
+            catch {
+                console.warn(chalk.yellow('⚠ Could not initialize git repository'));
             }
         }
-        const chosenAddOns = await finalizeAddOns(framework, defaultMode, Array.from(selectedAddOns));
-        const finalOptions = {
-            projectName: resolvedProjectName,
-            targetDir,
-            framework,
-            mode: defaultMode,
-            typescript: true,
-            tailwind: true,
-            packageManager: options.packageManager ||
-                getPackageManager() ||
-                DEFAULT_PACKAGE_MANAGER,
-            git: options.git !== false,
-            install: options.install !== false,
-            chosenAddOns,
-            addOnOptions: {
-                ...populateAddOnOptionsDefaults(chosenAddOns),
-                project: { bareBones: options.bareBones ?? true },
-            },
-        };
-        environment.intro(`Creating a new ${appName} app in ${resolvedProjectName}...`);
-        await createApp(environment, finalOptions);
-        // Delete files specified in bareBones.deleteFiles for each add-on when in bare-bones mode
-        if (options.bareBones !== false) {
-            for (const addOn of chosenAddOns) {
-                const addOnWithBareBones = addOn;
-                if (addOnWithBareBones.bareBones?.deleteFiles) {
-                    for (const file of addOnWithBareBones.bareBones.deleteFiles) {
-                        const filePath = join(targetDir, file);
-                        try {
-                            await unlink(filePath);
-                        }
-                        catch {
-                            // File may not exist, ignore errors
-                        }
-                    }
-                }
+        // Install dependencies
+        if (options.install !== false) {
+            const pm = options.packageManager ??
+                getPackageManagerFromUserAgent() ??
+                'pnpm';
+            console.log(chalk.gray(`⟳ Installing dependencies with ${pm}...`));
+            try {
+                execSync(`${pm} install`, { cwd: targetDir, stdio: 'inherit' });
+                console.log(chalk.green('✓ Dependencies installed'));
             }
+            catch {
+                console.error(chalk.red(`Failed to install dependencies. Run \`${pm} install\` manually.`));
+            }
+        }
+        console.log(chalk.bold.green('\nDone! Your project is ready.'));
+        console.log(chalk.white('\nNext steps:'));
+        console.log(chalk.cyan(`  cd ${basename(targetDir)}`));
+        if (options.install === false) {
+            const pm = options.packageManager ??
+                getPackageManagerFromUserAgent() ??
+                'pnpm';
+            console.log(chalk.cyan(`  ${pm} install`));
         }
-        // Generate an AGENTS.md file in the root of the project
-        await generateAgentsMd(targetDir, resolvedProjectName, chosenAddOns);
+        console.log(chalk.cyan('  pnpm dev'));
     });
     program.parse();
 }

package/dist/index.js

@@ -1,33 +1,3 @@
 #!/usr/bin/env node
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { registerFramework, scanAddOnDirectories, scanProjectDirectory, } from '@tanstack/cta-engine';
 import { cli } from './cli.js';
-const projectDirectory = join(dirname(dirname(fileURLToPath(import.meta.url))), 'project');
-const addOns = scanAddOnDirectories([
-    join(dirname(dirname(fileURLToPath(import.meta.url))), 'add-ons'),
-    join(dirname(dirname(fileURLToPath(import.meta.url))), 'examples'),
-]);
-const { files, basePackageJSON, optionalPackages } = scanProjectDirectory(projectDirectory, join(dirname(dirname(fileURLToPath(import.meta.url))), 'project', 'base'));
-registerFramework({
-    id: 'netlify-start',
-    name: 'Netlify TanStack Start',
-    description: 'TanStack Start applications for Netlify deployment',
-    version: '0.1.0',
-    base: files,
-    addOns,
-    basePackageJSON,
-    optionalPackages,
-    supportedModes: {
-        'file-router': {
-            displayName: 'File Router',
-            description: 'File-based routing with TanStack Start',
-            forceTypescript: true,
-        },
-    },
-});
-cli({
-    name: 'netlify-cta',
-    appName: 'Netlify TanStack Start',
-    defaultFramework: 'Netlify TanStack Start',
-});
+cli();

package/dist/types/cli.d.ts

@@ -1,8 +1 @@
-export interface CliConfig {
-    name: string;
-    appName: string;
-    defaultFramework: string;
-    forcedMode?: string;
-    forcedAddOns?: Array<string>;
-}
-export declare function cli({ name, appName, defaultFramework, forcedMode, forcedAddOns, }: CliConfig): void;
+export declare function cli(): void;

package/dist/types/types.d.ts

@@ -1,14 +1,9 @@
-import type { PackageManager } from '@tanstack/cta-engine';
 export interface CliOptions {
-    projectName?: string;
-    packageManager?: PackageManager;
-    git?: boolean;
-    addOns?: Array<string> | boolean;
-    listAddOns?: boolean;
-    listAddonsJson?: boolean;
-    addonDetails?: string;
-    targetDir?: string;
-    install?: boolean;
-    force?: boolean;
-    bareBones?: boolean;
+    install: boolean;
+    packageManager: string | undefined;
+    addOns: string | boolean | undefined;
+    listAddonsJson: boolean;
+    git: boolean;
+    force: boolean | undefined;
+    targetDir: string | undefined;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kaddidlehopper",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Create TanStack Start applications for Netlify",
   "bin": "./dist/index.js",
   "type": "module",
@@ -18,7 +18,6 @@
   "author": "Jack Herrington <jherr@pobox.com>",
   "license": "MIT",
   "dependencies": {
-    "@tanstack/cta-engine": "^0.48.0",
     "chalk": "^5.4.1",
     "commander": "^13.1.0",
     "validate-npm-package-name": "^7.0.0"