feat: make the e2e feature require counter

Add a one-directional, transitively-resolved `requires` field to
FeatureDefinition; `e2e` declares `requires: ['counter']` because the suite
drives the counter dapp. Resolution lives in pure helpers in utils.ts:

- resolveSelectedFeatures expands a selection with its transitive requirements
  (non-interactive: --features e2e yields [counter, e2e])
- applyFeatureToggle keeps the interactive multiselect consistent — selecting
  pulls requirements in, deselecting cascades dependents out

--info surfaces each feature's `requires` so agents can resolve dependencies
themselves, and --help documents the auto-resolution.

Author: fernandomg

architecture.md

@@ -85,11 +85,14 @@ type FeatureDefinition = {
   default: boolean      // --info output
   postInstall?: string[] // post-install instructions for non-interactive JSON output
   paths?: string[]       // files/dirs removed when the feature is deselected (Canton, data-driven cleanup)
+  requires?: FeatureName[] // features this one depends on (one-directional, transitive)
 }
 ```
 
 When adding a new feature, add it to the relevant stack's `features` map. Programmatic consumers pick it up automatically. Canton feature cleanup is fully data-driven from `paths` (see `cleanupFiles.ts` below), so a new Canton feature needs no cleanup code — only its `paths`. EVM features still need an explicit per-feature cleanup function. The CLI `--help` text in `cli.tsx` maintains its own copy in both cases.
 
+**Feature dependencies (`requires`)** are resolved by pure helpers in `utils.ts`. `resolveSelectedFeatures(stack, selected)` expands a selection to include every transitive requirement (used by the non-interactive path, so `--features e2e` yields `[counter, e2e]`). `applyFeatureToggle(stack, selection, toggled, action)` keeps the interactive multiselect consistent: selecting a feature pulls its requirements in, deselecting one cascades its dependents out. `e2e requires counter` is the only dependency today. `--info` surfaces each feature's `requires` so agents can resolve dependencies themselves.
+
 ### Operations Layer (`source/operations/`)
 
 Plain async functions, no UI dependencies. Each operation that varies per stack takes `stack: Stack` as its first argument. Multi-step operations accept an optional `onProgress` callback for the TUI; the non-interactive path omits it.

readme.md

@@ -138,10 +138,14 @@ pnpm dlx dappbooster --canton --ni --name my_canton --mode custom --features cou
 | Feature | Key | Default | Description |
 |---|---|---|---|
 | Counter demo | `counter` | ✓ | Counter demo dapp (frontend + Daml + wallet-service) |
-| E2E tests | `e2e` | ✓ | Playwright end-to-end test suite |
+| E2E tests | `e2e` | ✓ | Playwright end-to-end test suite (**requires `counter`**) |
 | Carpincho wallet | `carpincho` | ✓ | Carpincho browser-extension wallet (frontend + build tooling) |
 | LLM & agent artifacts | `llm` | ✓ | `.claude`, `AGENTS.md`, `CLAUDE.md`, `architecture.md`, `llms.txt`, … |
 
+`e2e` drives the counter dapp, so it **requires** `counter`: requesting `--features e2e` auto-pulls
+`counter` in (the success JSON reports `["counter", "e2e"]`), and in the wizard, deselecting
+`counter` also unchecks `e2e`.
+
 The Canton scaffold uses **npm** (a property of the generated project, not this installer). After
 install: review `canton-barebones/.env`, run `npm run canton:up` to start the local Canton stack,
 and `npm run app:dev` to run the counter dapp frontend. When `carpincho` is included, build the

source/__tests__/info.test.ts

@@ -65,14 +65,35 @@ describe('getInfoOutput — no filter', () => {
     }
   })
 
-  it('does not leak label or packages into feature output', () => {
+  it('surfaces requires only for features that declare a dependency', () => {
+    const output = JSON.parse(getInfoOutput())
+
+    for (const stack of stackNames) {
+      for (const [name, def] of Object.entries(stackDefinitions[stack].features)) {
+        const feature = output.stacks[stack].features[name]
+        if (def.requires) {
+          expect(feature.requires).toEqual(def.requires)
+        } else {
+          expect(feature).not.toHaveProperty('requires')
+        }
+      }
+    }
+  })
+
+  it('exposes the e2e -> counter dependency for agents', () => {
+    const output = JSON.parse(getInfoOutput('canton'))
+    expect(output.stacks.canton.features.e2e.requires).toEqual(['counter'])
+  })
+
+  it('does not leak label, packages, or paths into feature output', () => {
     const output = JSON.parse(getInfoOutput())
 
     for (const stack of stackNames) {
       for (const name of Object.keys(stackDefinitions[stack].features)) {
         const feature = output.stacks[stack].features[name]
         expect(feature).not.toHaveProperty('label')
         expect(feature).not.toHaveProperty('packages')
+        expect(feature).not.toHaveProperty('paths')
       }
     }
   })

source/__tests__/nonInteractive.test.ts

@@ -295,6 +295,28 @@ describe('nonInteractive — canton execution', () => {
     const postInstall = output.postInstall as string[]
     expect(postInstall.some((msg) => msg.includes('canton:up'))).toBe(true)
   })
+
+  it('auto-pulls counter when only e2e is requested (e2e requires counter)', async () => {
+    await runNonInteractive({
+      stack: 'canton',
+      name: 'my_app',
+      mode: 'custom',
+      features: 'e2e',
+    })
+
+    expect(installPackages).toHaveBeenCalledWith(
+      'canton',
+      expect.stringContaining('my_app'),
+      'custom',
+      ['counter', 'e2e'],
+    )
+
+    const output = getLastJsonOutput()
+    expect(output.features).toEqual(['counter', 'e2e'])
+    // counter's post-install messages come along with the pulled-in feature
+    const postInstall = output.postInstall as string[]
+    expect(postInstall.some((msg) => msg.includes('canton:up'))).toBe(true)
+  })
 })
 
 describe('nonInteractive — custom mode execution', () => {

source/__tests__/utils.test.ts

@@ -1,11 +1,13 @@
 import { describe, expect, it } from 'vitest'
 import { stackDefinitions } from '../constants/config.js'
 import {
+  applyFeatureToggle,
   deriveStepDisplay,
   getPackagesToRemove,
   getPostInstallMessages,
   isFeatureSelected,
   isValidName,
+  resolveSelectedFeatures,
 } from '../utils/utils.js'
 
 const evmFeatures = stackDefinitions.evm.features
@@ -136,6 +138,66 @@ describe('getPostInstallMessages', () => {
   })
 })
 
+describe('resolveSelectedFeatures — canton (e2e requires counter)', () => {
+  it('pulls counter in when only e2e is selected', () => {
+    expect(resolveSelectedFeatures('canton', ['e2e'])).toEqual(['counter', 'e2e'])
+  })
+
+  it('leaves an already-complete selection unchanged', () => {
+    expect(resolveSelectedFeatures('canton', ['counter', 'e2e'])).toEqual(['counter', 'e2e'])
+  })
+
+  it('orders the resolved set by config order, not selection order', () => {
+    expect(resolveSelectedFeatures('canton', ['e2e', 'carpincho'])).toEqual([
+      'counter',
+      'e2e',
+      'carpincho',
+    ])
+  })
+
+  it('does not pull e2e in when only counter is selected (one-directional)', () => {
+    expect(resolveSelectedFeatures('canton', ['counter'])).toEqual(['counter'])
+  })
+
+  it('de-duplicates when a requirement is already present', () => {
+    expect(resolveSelectedFeatures('canton', ['counter', 'e2e', 'carpincho'])).toEqual([
+      'counter',
+      'e2e',
+      'carpincho',
+    ])
+  })
+})
+
+describe('resolveSelectedFeatures — evm (no requires)', () => {
+  it('returns the selection unchanged, in config order', () => {
+    expect(resolveSelectedFeatures('evm', ['subgraph', 'demo'])).toEqual(['demo', 'subgraph'])
+  })
+})
+
+describe('applyFeatureToggle — canton (interactive cascade)', () => {
+  it('selecting e2e pulls counter in', () => {
+    expect(applyFeatureToggle('canton', ['carpincho'], 'e2e', 'select')).toEqual([
+      'counter',
+      'e2e',
+      'carpincho',
+    ])
+  })
+
+  it('unselecting counter cascades e2e out', () => {
+    expect(
+      applyFeatureToggle('canton', ['counter', 'e2e', 'carpincho'], 'counter', 'unselect'),
+    ).toEqual(['carpincho'])
+  })
+
+  it('unselecting e2e leaves counter alone', () => {
+    expect(applyFeatureToggle('canton', ['counter', 'e2e'], 'e2e', 'unselect')).toEqual(['counter'])
+  })
+
+  it('selecting counter does not pull e2e', () => {
+    expect(applyFeatureToggle('canton', [], 'counter', 'select')).toEqual(['counter'])
+  })
+})
+
 describe('deriveStepDisplay', () => {
   it('shows all steps as completed when done', () => {
     const result = deriveStepDisplay(['Step 1', 'Step 2', 'Step 3'], 'done')

source/cli.tsx

@@ -27,9 +27,11 @@ const cli = meow(
                                  husky      Git hooks (Husky, lint-staged, commitlint)
                                Canton:
                                  counter    Counter demo dapp
-                                 e2e        Playwright end-to-end tests
+                                 e2e        Playwright end-to-end tests (requires counter)
                                  carpincho  Carpincho browser-extension wallet
                                  llm        LLM and agent artifacts (.claude, AGENTS.md, …)
+                               Dependencies are auto-resolved: requesting e2e
+                               also pulls in counter.
     --non-interactive, --ni  Run without prompts (auto-enabled when not a TTY)
     --info                   Output feature metadata as JSON (filter with --stack)
     --help                   Show this help
@@ -41,8 +43,11 @@ const cli = meow(
     Use --ni to force non-interactive mode in a TTY environment.
 
     AI agents: non-interactive mode activates automatically. Run --info
-    to discover available stacks and features, then pass --canton or --evm
-    plus --name and --mode flags. Output is JSON for easy parsing.
+    to discover available stacks and features (including each feature's
+    "requires"), then pass --canton or --evm plus --name and --mode flags.
+    Feature dependencies are resolved automatically, so the returned
+    "features" list may include extras pulled in by your selection.
+    Output is JSON for easy parsing.
 
   Examples
     Interactive (prompts for stack and options):

source/components/Multiselect/MultiSelect.tsx

@@ -23,6 +23,13 @@ type MultiSelectProps<T> = {
   onUnselect?: (unselectedItem: Item<T>) => void
   onSubmit?: (selectedItems: Item<T>[]) => void
   onHighlight?: (highlightedItem: Item<T>) => void
+  // Optional hook to post-process a toggle (e.g. enforce feature dependencies). Receives the
+  // naive post-toggle selection plus the item that was toggled and the action taken.
+  transformSelection?: (
+    nextSelected: Item<T>[],
+    toggledItem: Item<T>,
+    action: 'select' | 'unselect',
+  ) => Item<T>[]
 }
 
 const MultiSelect = <T,>({
@@ -38,6 +45,7 @@ const MultiSelect = <T,>({
   onUnselect = () => {},
   onSubmit = () => {},
   onHighlight = () => {},
+  transformSelection,
 }: MultiSelectProps<T>) => {
   const [highlightedIndex, setHighlightedIndex] = useState(initialIndex)
   const [selectedItems, setSelectedItems] = useState(defaultSelected)
@@ -56,19 +64,29 @@ const MultiSelect = <T,>({
 
   const handleSelect = useCallback(
     (item: Item<T>) => {
-      if (includesItems(item, selectedItems)) {
-        const newSelectedItems = selectedItems.filter(
-          (selectedItem) => selectedItem.value !== item.value && selectedItem.label !== item.label,
-        )
-        setSelectedItems(newSelectedItems)
+      const isCurrentlySelected = includesItems(item, selectedItems)
+      const action = isCurrentlySelected ? 'unselect' : 'select'
+
+      const naiveSelection = isCurrentlySelected
+        ? selectedItems.filter(
+            (selectedItem) =>
+              selectedItem.value !== item.value && selectedItem.label !== item.label,
+          )
+        : [...selectedItems, item]
+
+      const nextSelection = transformSelection
+        ? transformSelection(naiveSelection, item, action)
+        : naiveSelection
+
+      setSelectedItems(nextSelection)
+
+      if (isCurrentlySelected) {
         onUnselect(item)
       } else {
-        const newSelectedItems = [...selectedItems, item]
-        setSelectedItems(newSelectedItems)
         onSelect(item)
       }
     },
-    [selectedItems, onSelect, onUnselect, includesItems],
+    [selectedItems, onSelect, onUnselect, includesItems, transformSelection],
   )
 
   const handleSubmit = useCallback(() => {

source/components/steps/OptionalPackages.tsx

@@ -1,7 +1,8 @@
 import { Text } from 'ink'
-import { type FC, useEffect, useMemo, useState } from 'react'
-import { type Stack, getStackConfig } from '../../constants/config.js'
+import { type FC, useCallback, useEffect, useMemo, useState } from 'react'
+import { type FeatureName, type Stack, getStackConfig } from '../../constants/config.js'
 import type { MultiSelectItem } from '../../types/types.js'
+import { applyFeatureToggle } from '../../utils/utils.js'
 import MultiSelect from '../Multiselect/index.js'
 
 interface Props {
@@ -22,6 +23,27 @@ const OptionalPackages: FC<Props> = ({ stack, onCompletion, onSubmit, skip = fal
     }))
   }, [stack])
 
+  // Keep the selection dependency-consistent as the user toggles (e.g. e2e requires counter).
+  const transformSelection = useCallback(
+    (
+      nextSelected: Array<MultiSelectItem>,
+      toggledItem: MultiSelectItem,
+      action: 'select' | 'unselect',
+    ): Array<MultiSelectItem> => {
+      const selectedValues = nextSelected.map((item) => item.value as FeatureName)
+      const resolved = applyFeatureToggle(
+        stack,
+        selectedValues,
+        toggledItem.value as FeatureName,
+        action,
+      )
+      return resolved
+        .map((value) => customPackages.find((pkg) => pkg.value === value))
+        .filter((pkg): pkg is MultiSelectItem => pkg !== undefined)
+    },
+    [stack, customPackages],
+  )
+
   // biome-ignore lint/correctness/useExhaustiveDependencies: Run this only once, no matter what
   useEffect(() => {
     if (skip) {
@@ -61,6 +83,7 @@ const OptionalPackages: FC<Props> = ({ stack, onCompletion, onSubmit, skip = fal
         focus
         items={customPackages}
         onSubmit={onHandleSubmit}
+        transformSelection={transformSelection}
       />
     </>
   )

source/constants/config.ts

@@ -17,6 +17,9 @@ export type FeatureDefinition = {
   // Relative paths removed when the feature is deselected (custom mode). Directory paths also
   // drive package.json script stripping via scriptTargetsRemovedDir in cleanupFiles.
   paths?: string[]
+  // Other features this one depends on. Selecting it pulls these in; deselecting one of these
+  // cascades this feature out. One-directional and resolved transitively (see utils.ts).
+  requires?: FeatureName[]
 }
 
 export type EnvFile = {
@@ -130,11 +133,12 @@ export const stackDefinitions: Record<Stack, StackConfig> = {
         ],
       },
       e2e: {
-        description: 'Playwright end-to-end test suite',
+        description: 'Playwright end-to-end test suite (drives the counter dapp)',
         label: 'E2E tests',
         packages: [],
         default: true,
         paths: ['e2e'],
+        requires: ['counter'],
       },
       carpincho: {
         description: 'Carpincho browser-extension wallet (frontend + build tooling)',

source/info.ts

@@ -4,6 +4,7 @@ type FeatureInfo = {
   description: string
   default: boolean
   postInstall?: string[]
+  requires?: string[]
 }
 
 type StackInfo = {
@@ -27,6 +28,7 @@ function buildStackInfo(stack: Stack): StackInfo {
           description: def.description,
           default: def.default,
           ...(def.postInstall ? { postInstall: def.postInstall } : {}),
+          ...(def.requires ? { requires: def.requires } : {}),
         },
       ]),
     ),