feat: add non-interactive CLI with meow arg parsing

Rewrite cli.tsx with meow for arg parsing and routing between
interactive and non-interactive modes. Add --info output builder
and non-interactive execution path that runs the full setup
(clone, install, env, cleanup) without the TUI.

Author: fernandomg

source/cli.tsx

@@ -1,6 +1,99 @@
 #!/usr/bin/env node
-import { render } from 'ink'
-import App from './app.js'
+import process from 'node:process'
+import meow from 'meow'
+import { getInfoOutput } from './info.js'
+import { runNonInteractive } from './nonInteractive.js'
 
-console.clear()
-render(<App />)
+const cli = meow(
+  `
+  Usage
+    $ dappbooster-starter [options]
+
+  Options
+    --name <string>          Project name (alphanumeric, underscores)
+    --mode <full|custom>     Installation mode
+    --features <list>        Comma-separated features (with --mode=custom):
+                               demo       Component demos and example pages
+                               subgraph   TheGraph subgraph integration (requires API key)
+                               typedoc    TypeDoc API documentation generation
+                               vocs       Vocs documentation site
+                               husky      Git hooks with Husky, lint-staged, commitlint
+    --non-interactive, --ni  Run without prompts (auto-enabled when not a TTY)
+    --info                   Output feature metadata as JSON
+    --help                   Show this help
+    --version                Show version
+
+  Non-interactive mode
+    Requires --name and --mode. Outputs JSON to stdout.
+    Activates automatically when stdout is not a TTY.
+    Use --ni to force non-interactive mode in a TTY environment.
+
+    AI agents: non-interactive mode activates automatically. Run --info
+    to discover available features, then pass --name and --mode flags.
+    Output is JSON for easy parsing.
+
+  Examples
+    Interactive:
+      $ dappbooster-starter
+
+    Full install (non-interactive):
+      $ dappbooster-starter --ni --name my_dapp --mode full
+
+    Custom install with specific features:
+      $ dappbooster-starter --ni --name my_dapp --mode custom --features demo,subgraph
+
+    Get feature metadata:
+      $ dappbooster-starter --info
+`,
+  {
+    importMeta: import.meta,
+    flags: {
+      name: {
+        type: 'string',
+      },
+      mode: {
+        type: 'string',
+      },
+      features: {
+        type: 'string',
+      },
+      nonInteractive: {
+        type: 'boolean',
+        default: false,
+      },
+      ni: {
+        type: 'boolean',
+        default: false,
+      },
+      info: {
+        type: 'boolean',
+        default: false,
+      },
+    },
+  },
+)
+
+if (cli.flags.info) {
+  console.log(getInfoOutput())
+  process.exit(0)
+}
+
+const isNonInteractive = cli.flags.nonInteractive || cli.flags.ni || !process.stdout.isTTY
+
+if (isNonInteractive) {
+  runNonInteractive({
+    name: cli.flags.name,
+    mode: cli.flags.mode,
+    features: cli.flags.features,
+  })
+} else {
+  const run = async () => {
+    console.clear()
+    const { render } = await import('ink')
+    const { default: App } = await import('./app.js')
+
+    render(<App />)
+  }
+
+  run()
+}

source/info.ts

@@ -0,0 +1,26 @@
+import { featureDefinitions } from './constants/config.js'
+
+export function getInfoOutput(): string {
+  const features = Object.fromEntries(
+    Object.entries(featureDefinitions).map(([name, def]) => [
+      name,
+      {
+        description: def.description,
+        default: def.default,
+        ...(def.postInstall ? { postInstall: def.postInstall } : {}),
+      },
+    ]),
+  )
+
+  return JSON.stringify(
+    {
+      features,
+      modes: {
+        full: 'Install all features',
+        custom: 'Choose features individually',
+      },
+    },
+    null,
+    2,
+  )
+}

source/nonInteractive.ts

@@ -0,0 +1,120 @@
+import process from 'node:process'
+import { type FeatureName, featureNames } from './constants/config.js'
+import { cleanupFiles, cloneRepo, createEnvFile, installPackages } from './operations/index.js'
+import type { InstallationType } from './types/types.js'
+import {
+  getPostInstallMessages,
+  getProjectFolder,
+  isValidName,
+  projectDirectoryExists,
+} from './utils/utils.js'
+
+type SuccessResult = {
+  success: true
+  projectName: string
+  mode: InstallationType
+  features: FeatureName[]
+  path: string
+  postInstall: string[]
+}
+
+type ErrorResult = {
+  success: false
+  error: string
+}
+
+function fail(error: string): never {
+  const result: ErrorResult = { success: false, error }
+  console.log(JSON.stringify(result, null, 2))
+  process.exit(1)
+}
+
+function parseFeatures(featuresFlag: string | undefined): FeatureName[] {
+  if (!featuresFlag) {
+    return []
+  }
+
+  return featuresFlag.split(',').map((f) => f.trim()) as FeatureName[]
+}
+
+function validate(flags: {
+  name?: string
+  mode?: string
+  features?: string
+}): { name: string; mode: InstallationType; features: FeatureName[] } {
+  if (!flags.name) {
+    fail('Missing required flag: --name')
+  }
+
+  if (!flags.mode) {
+    fail('Missing required flag: --mode')
+  }
+
+  if (!isValidName(flags.name)) {
+    fail('Invalid project name: only letters, numbers, and underscores are allowed')
+  }
+
+  if (flags.mode !== 'full' && flags.mode !== 'custom') {
+    fail("Invalid mode: must be 'full' or 'custom'")
+  }
+
+  // --mode=full ignores --features (everything is installed)
+  if (flags.mode === 'full') {
+    if (projectDirectoryExists(flags.name)) {
+      fail(`Project directory '${flags.name}' already exists`)
+    }
+
+    return { name: flags.name, mode: flags.mode, features: [] }
+  }
+
+  if (!flags.features) {
+    fail('--mode custom requires --features. Use --info to see available features.')
+  }
+
+  const features = parseFeatures(flags.features)
+  const invalidFeatures = features.filter((f) => !featureNames.includes(f))
+
+  if (invalidFeatures.length > 0) {
+    fail(
+      `Unknown features: ${invalidFeatures.join(', ')}. Valid features: ${featureNames.join(', ')}`,
+    )
+  }
+
+  if (projectDirectoryExists(flags.name)) {
+    fail(`Project directory '${flags.name}' already exists`)
+  }
+
+  return { name: flags.name, mode: flags.mode, features }
+}
+
+export async function runNonInteractive(flags: {
+  name?: string
+  mode?: string
+  features?: string
+}): Promise<void> {
+  const { name, mode, features } = validate(flags)
+
+  try {
+    await cloneRepo(name)
+
+    const projectFolder = getProjectFolder(name)
+
+    await createEnvFile(projectFolder)
+    await installPackages(projectFolder, mode, features)
+    await cleanupFiles(projectFolder, mode, features)
+
+    const result: SuccessResult = {
+      success: true,
+      projectName: name,
+      mode,
+      features,
+      path: projectFolder,
+      postInstall: getPostInstallMessages(mode, features),
+    }
+
+    console.log(JSON.stringify(result, null, 2))
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    fail(message)
+  }
+}