kaddidlehopper 0.5.0 → 0.7.0

package/src/cli.ts

@@ -1,29 +1,19 @@
-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'
 import type { CliOptions } from './types.js'
-import type {
-  Options,
-  PackageManager,
-} from '@tanstack/cta-engine'
 
-// 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: string): string {
   return name
     .toLowerCase()
@@ -52,303 +42,196 @@ function validateProjectName(name: string) {
   }
 }
 
-// Create environment with UI functions for console output
-function createEnvironment(appName: string) {
-  const env = createDefaultEnvironment()
-  env.appName = appName
-  env.intro = (message: string) => console.log(chalk.bold.cyan(message))
-  env.outro = (message: string) => console.log(chalk.bold.green(message))
-  env.info = (title?: string, message?: string) => {
-    if (title && message) {
-      console.log(chalk.blue(`${title}: ${message}`))
-    } else if (title) {
-      console.log(chalk.blue(title))
-    }
-  }
-  env.error = (title?: string, message?: string) => {
-    if (title && message) {
-      console.error(chalk.red(`${title}: ${message}`))
-    } else if (title) {
-      console.error(chalk.red(title))
-    }
-  }
-  env.warn = (title?: string, message?: string) => {
-    if (title && message) {
-      console.warn(chalk.yellow(`${title}: ${message}`))
-    } else if (title) {
-      console.warn(chalk.yellow(title))
-    }
-  }
-  env.spinner = () => ({
-    start: (message: string) => console.log(chalk.gray(`⟳ ${message}`)),
-    stop: (message: string) => console.log(chalk.green(`✓ ${message}`)),
-  })
-  return env
+function getPackageManagerFromUserAgent(): string | undefined {
+  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 interface CliConfig {
-  name: string
-  appName: string
-  defaultFramework: string
-  forcedMode?: string
-  forcedAddOns?: Array<string>
-}
-
-export function cli({
-  name,
-  appName,
-  defaultFramework,
-  forcedMode,
-  forcedAddOns = [],
-}: CliConfig) {
-  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<PackageManager>(
-      `--package-manager <${SUPPORTED_PACKAGE_MANAGERS.join('|')}>`,
-      `Explicitly tell the CLI to use this package manager`,
-      (value) => {
-        if (!SUPPORTED_PACKAGE_MANAGERS.includes(value as PackageManager)) {
-          throw new InvalidArgumentError(
-            `Invalid package manager: ${value}. The following are allowed: ${SUPPORTED_PACKAGE_MANAGERS.join(', ')}`,
-          )
-        }
-        return value as PackageManager
-      },
-    )
-    .option<Array<string> | boolean>(
-      '--add-ons [...add-ons]',
-      'pick from a list of available add-ons (comma separated list)',
-      (value: string) => {
-        let addOns: Array<string> | boolean = !!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',
+      '--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)',
-    )
-
-  program.action(async (projectName: string, options: CliOptions) => {
-    const framework = getFrameworkByName(defaultFramework)
-    if (!framework) {
-      console.error(`Framework '${defaultFramework}' not found`)
-      process.exit(1)
-    }
 
+  program.action(async (projectName: string | undefined, options: CliOptions) => {
     // 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 as unknown as { features?: Array<string> }).features ?? [],
-          options: addon.options,
-        }))
-      console.log(JSON.stringify(serialized, null, 2))
-      return
+      const manifest = await fetch(MANIFEST_URL).then((r) => r.json()) as { starters: unknown }
+      console.log(JSON.stringify(manifest.starters, null, 2))
+      process.exit(0)
     }
 
-    // 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
+    // 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: string
+    if (projectName && projectName !== '.') {
+      resolvedProjectName = sanitizePackageName(projectName)
+    } else {
+      resolvedProjectName = sanitizePackageName(getCurrentDirectoryName())
+    }
+
+    const { valid, error } = validateProjectName(resolvedProjectName)
+    if (!valid) {
+      console.error(chalk.red(error))
+      process.exit(1)
     }
 
-    // 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`)
+    // 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)}`,
+    // 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}`))
+
+    // Fetch manifest to resolve frameworkId for this starter
+    type StarterEntry = { id: string; framework?: string }
+    const manifest = await fetch(MANIFEST_URL).then((r) => r.json()) as { starters: StarterEntry[] }
+    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' },
       )
-      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(', ')}`,
+      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 as { label: string; description?: string; type: string; default: unknown; options?: Array<{ value: string; label: string }> }
-            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: string
-    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
-    }
 
-    const { valid, error } = validateProjectName(resolvedProjectName)
-    if (!valid) {
-      console.error(error)
-      process.exit(1)
+      console.log(chalk.green(`✓ Template copied`))
+    } finally {
+      await rm(tmpDir, { recursive: true, force: true })
     }
 
-    // Determine selected add-ons
-    const selectedAddOns = new Set<string>([...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: Options = {
-      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 as typeof addOn & {
-          bareBones?: { deleteFiles?: Array<string> }
-        }
-        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.`,
+          ),
+        )
       }
     }
 
-    // Generate an AGENTS.md file in the root of the project
-    await generateAgentsMd(targetDir, resolvedProjectName, chosenAddOns as Array<{ packageFileDescriptions?: Record<string, string> }>)
+    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`))
+    }
+    console.log(chalk.cyan('  pnpm dev'))
   })
 
   program.parse()

package/src/index.ts

@@ -1,49 +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/src/types.ts

@@ -1,15 +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
 }