openuispec 0.1.27 → 0.1.29

package/README.md

@@ -53,6 +53,7 @@ openuispec init
 ```
 
 This scaffolds a spec directory, starter tokens, and adds rules to `CLAUDE.md` / `AGENTS.md` so AI assistants track spec changes automatically.
+Use `openuispec init --no-configure-targets` if you want to scaffold first and choose target stacks later.
 
 Then hand your spec to any AI code generator:
 
@@ -68,7 +69,7 @@ For platform generation, treat these as hard output constraints:
 
 See the examples for concrete reference projects:
 
-- [TaskFlow](./examples/taskflow/) for a compact spec covering all 7 contract families
+- [TaskFlow](./examples/taskflow/openuispec/) for a compact reference spec covering all 7 contract families, with generated iOS, Android, and web targets under `examples/taskflow/generated/`
 - [Todo Orbit](./examples/todo-orbit/openuispec/) for a bilingual task app with generated iOS, Android, and web targets under `examples/todo-orbit/generated/`
 
 ## Repository structure
@@ -102,47 +103,22 @@ openuispec/
 │   │   └── validation.schema.json     # Validation rule definitions
 │   └── validate.ts                     # Validation script (npm run validate)
 ├── examples/
-│   ├── taskflow/                        # Compact reference spec
-│   │   ├── openuispec.yaml              # Root manifest + data model + API endpoints
-│   │   ├── tokens/
-│   │   │   ├── color.yaml               # Brand + semantic + status colors
-│   │   │   ├── typography.yaml          # Font family + 8-step type scale
-│   │   │   ├── spacing.yaml             # 4px base unit, 9-step scale
-│   │   │   ├── elevation.yaml           # 4-level elevation (none/sm/md/lg)
-│   │   │   ├── motion.yaml              # Durations, easings, patterns
-│   │   │   ├── layout.yaml              # Size classes, primitives, reflow rules
-│   │   │   ├── themes.yaml              # Light, dark, warm variants
-│   │   │   └── icons.yaml               # Icon registry with platform mappings
-│   │   ├── contracts/                   # Standard contract extensions + custom contracts
-│   │   │   ├── input_field.yaml         # Standard contract with cut_corner variant
-│   │   │   └── x_media_player.yaml      # Custom media player contract (Section 12)
-│   │   ├── screens/
-│   │   │   ├── home.yaml                # Task list with search, filters, FAB, adaptive nav
-│   │   │   ├── task_detail.yaml         # Full task view with actions + assignee sheet
-│   │   │   ├── projects.yaml            # Project grid + new project dialog
-│   │   │   ├── project_detail.yaml      # Single project with task list (stub)
-│   │   │   ├── settings.yaml            # Preferences, toggles, account management
-│   │   │   ├── profile_edit.yaml        # Edit profile form (stub)
-│   │   │   └── calendar.yaml            # Calendar view (stub)
-│   │   ├── flows/
-│   │   │   ├── create_task.yaml         # Task creation form (sheet presentation)
-│   │   │   └── edit_task.yaml           # Task editing flow
-│   │   ├── locales/
-│   │   │   └── en.json                  # English locale (ICU MessageFormat)
-│   │   └── platform/
-│   │       ├── ios.yaml                 # SwiftUI overrides + behaviors
-│   │       ├── android.yaml             # Compose overrides + behaviors
-│   │       └── web.yaml                 # React overrides + responsive rules
-│   └── todo-orbit/                      # Full showcase app with generated targets
+│   ├── taskflow/                        # Compact reference sample
+│   │   ├── openuispec/                  # Source OpenUISpec project
+│   │   ├── generated/                   # Generated iOS, Android, and web apps
+│   │   ├── README.md                    # Sample overview and structure
+│   │   └── AGENTS.md / CLAUDE.md        # AI rules generated from the package
+│   └── todo-orbit/                      # Full showcase sample
 │       ├── openuispec/                  # Source OpenUISpec project
 │       ├── generated/                   # Generated iOS, Android, and web apps
-│       └── artifacts/                   # Screenshots and supporting outputs
+│       ├── README.md                    # Sample overview and structure
+│       └── AGENTS.md / CLAUDE.md        # AI rules generated from the package
 ├── cli/                                 # CLI tool (openuispec init, drift, prepare, validate)
 │   ├── index.ts                        # Entry point
 │   └── init.ts                         # Project scaffolding + AI rules
 ├── drift/                               # Drift detection (spec change tracking)
 │   └── index.ts                        # Hash-based drift checker
-├── prepare/                             # AI-ready target work bundle generation
+├── prepare/                             # Target work bundle generation
 │   └── index.ts                        # Baseline-aware target preparation
 ├── LICENSE
 └── README.md
@@ -154,21 +130,21 @@ Every file type has a corresponding JSON Schema in `schema/`. **Read the schema
 
 | File | Schema | Root key | Example |
 |------|--------|----------|---------|
-| `openuispec.yaml` | `openuispec.schema.json` | `spec_version` | [openuispec.yaml](./examples/taskflow/openuispec.yaml) |
-| `screens/*.yaml` | `screen.schema.json` | `<screen_id>` | [home.yaml](./examples/taskflow/screens/home.yaml) |
-| `flows/*.yaml` | `flow.schema.json` | `<flow_id>` | [create_task.yaml](./examples/taskflow/flows/create_task.yaml) |
-| `platform/*.yaml` | `platform.schema.json` | `platform` | [ios.yaml](./examples/taskflow/platform/ios.yaml) |
-| `locales/*.json` | `locale.schema.json` | (object) | [en.json](./examples/taskflow/locales/en.json) |
-| `contracts/<name>.yaml` | `contract.schema.json` | `<contract_name>` | [input_field.yaml](./examples/taskflow/contracts/input_field.yaml) |
-| `contracts/x_*.yaml` | `custom-contract.schema.json` | `<x_name>` | [x_media_player.yaml](./examples/taskflow/contracts/x_media_player.yaml) |
-| `tokens/color.yaml` | `tokens/color.schema.json` | `color` | [color.yaml](./examples/taskflow/tokens/color.yaml) |
-| `tokens/typography.yaml` | `tokens/typography.schema.json` | `typography` | [typography.yaml](./examples/taskflow/tokens/typography.yaml) |
-| `tokens/spacing.yaml` | `tokens/spacing.schema.json` | `spacing` | [spacing.yaml](./examples/taskflow/tokens/spacing.yaml) |
-| `tokens/elevation.yaml` | `tokens/elevation.schema.json` | `elevation` | [elevation.yaml](./examples/taskflow/tokens/elevation.yaml) |
-| `tokens/motion.yaml` | `tokens/motion.schema.json` | `motion` | [motion.yaml](./examples/taskflow/tokens/motion.yaml) |
-| `tokens/layout.yaml` | `tokens/layout.schema.json` | `layout` | [layout.yaml](./examples/taskflow/tokens/layout.yaml) |
-| `tokens/themes.yaml` | `tokens/themes.schema.json` | `themes` | [themes.yaml](./examples/taskflow/tokens/themes.yaml) |
-| `tokens/icons.yaml` | `tokens/icons.schema.json` | `icons` | [icons.yaml](./examples/taskflow/tokens/icons.yaml) |
+| `openuispec.yaml` | `openuispec.schema.json` | `spec_version` | [openuispec.yaml](./examples/taskflow/openuispec/openuispec.yaml) |
+| `screens/*.yaml` | `screen.schema.json` | `<screen_id>` | [home.yaml](./examples/taskflow/openuispec/screens/home.yaml) |
+| `flows/*.yaml` | `flow.schema.json` | `<flow_id>` | [create_task.yaml](./examples/taskflow/openuispec/flows/create_task.yaml) |
+| `platform/*.yaml` | `platform.schema.json` | `platform` | [ios.yaml](./examples/taskflow/openuispec/platform/ios.yaml) |
+| `locales/*.json` | `locale.schema.json` | (object) | [en.json](./examples/taskflow/openuispec/locales/en.json) |
+| `contracts/<name>.yaml` | `contract.schema.json` | `<contract_name>` | [input_field.yaml](./examples/taskflow/openuispec/contracts/input_field.yaml) |
+| `contracts/x_*.yaml` | `custom-contract.schema.json` | `<x_name>` | [x_media_player.yaml](./examples/taskflow/openuispec/contracts/x_media_player.yaml) |
+| `tokens/color.yaml` | `tokens/color.schema.json` | `color` | [color.yaml](./examples/taskflow/openuispec/tokens/color.yaml) |
+| `tokens/typography.yaml` | `tokens/typography.schema.json` | `typography` | [typography.yaml](./examples/taskflow/openuispec/tokens/typography.yaml) |
+| `tokens/spacing.yaml` | `tokens/spacing.schema.json` | `spacing` | [spacing.yaml](./examples/taskflow/openuispec/tokens/spacing.yaml) |
+| `tokens/elevation.yaml` | `tokens/elevation.schema.json` | `elevation` | [elevation.yaml](./examples/taskflow/openuispec/tokens/elevation.yaml) |
+| `tokens/motion.yaml` | `tokens/motion.schema.json` | `motion` | [motion.yaml](./examples/taskflow/openuispec/tokens/motion.yaml) |
+| `tokens/layout.yaml` | `tokens/layout.schema.json` | `layout` | [layout.yaml](./examples/taskflow/openuispec/tokens/layout.yaml) |
+| `tokens/themes.yaml` | `tokens/themes.schema.json` | `themes` | [themes.yaml](./examples/taskflow/openuispec/tokens/themes.yaml) |
+| `tokens/icons.yaml` | `tokens/icons.schema.json` | `icons` | [icons.yaml](./examples/taskflow/openuispec/tokens/icons.yaml) |
 
 Every token file **must** have a single root wrapper key matching its type:
 
@@ -198,16 +174,33 @@ generation:
     web: "../web-ui/"
     android: "../kmp-ui/"
     ios: "../kmp-ui/iosApp/"
+  code_roots:
+    backend: "../api/"
 ```
 
 Paths are relative to `openuispec.yaml`. The `.openuispec-state.json` file is stored inside each output directory and records spec file hashes plus the git baseline commit metadata captured at snapshot time.
 
+If `api.endpoints` are declared, `generation.code_roots.backend` is required. It should point at the backend folder the AI must inspect when generating API clients or wiring request/response behavior.
+
+`openuispec drift --snapshot --target <target>` requires that target output directory to already exist. If it does not, generate the target code first, then snapshot the accepted baseline.
+
 Use the commands like this:
 - `openuispec validate` checks schema correctness
 - `openuispec validate semantic` checks cross-references such as locale keys, formatters, mappers, contracts, icons, navigation targets, and API endpoints
+- `openuispec init --no-configure-targets` scaffolds the spec project without running the target-stack wizard
+- `openuispec configure-target <t>` records target stack choices in `platform/<target>.yaml` using preset defaults, while still allowing custom framework/library values when the project uses something outside the catalog
 - `openuispec drift --target <t> --explain` explains semantic spec changes since that target's accepted baseline
-- `openuispec prepare --target <t>` turns those changes into an AI-ready target update bundle
-- `openuispec status` shows every target's snapshot state, baseline commit, and whether that target is behind the current spec
+- `openuispec prepare --target <t>` builds the target work bundle for either first-time generation or drift-based updates
+- `openuispec status` shows every target's snapshot state, baseline commit, and whether that target is behind the current spec, still needs a baseline, or has not been generated yet
+
+In first-time generation mode, `prepare` also carries target-specific generation constraints such as native localization requirements, multi-file output rules, target folder layout expectations, and a requirement to refresh current platform/framework setup knowledge before code generation.
+
+When target stack choices come from the preset catalog, `prepare --json` also exposes install-oriented refs for the selected options:
+- Android: Gradle plugin ids and library coordinates
+- Web: npm package specs
+- iOS: package identifiers plus docs links
+
+Those refs are anchors, not a full dependency manifest. The AI is expected to add any supporting build, plugin, repository, annotation-processing, runtime, dev, and test dependencies required by the current platform setup.
 
 If a target snapshot was created before baseline metadata was added, `--explain` and `status` will tell you to re-run `openuispec drift --snapshot --target <target>` for that target.
 
@@ -217,18 +210,22 @@ When a shared spec change needs to be applied to a target:
 
 ```bash
 openuispec validate
+openuispec validate semantic
+openuispec status
 openuispec drift --target ios --explain
 openuispec prepare --target ios
 # update the ios implementation
+# ensure the ios output directory already exists
 openuispec drift --snapshot --target ios
 ```
 
 Meaning:
 - `validate` checks schema correctness
 - `validate semantic` checks cross-reference integrity
+- `status` shows which targets are up to date, need a baseline, or still need generation
 - `drift --explain` shows semantic spec changes since that target's accepted baseline
-- `prepare` packages those changes into an AI/developer work bundle
-- `drift --snapshot` accepts the updated state after the target UI has been updated
+- `prepare` packages the target work bundle for AI/developers. It runs in `bootstrap` mode for first-time generation and `update` mode after a target snapshot exists.
+- `drift --snapshot` accepts the updated state after the target UI has been updated and the target output directory exists
 
 Before picking the next platform to update, run:
 
@@ -238,7 +235,7 @@ openuispec status
 
 to see which targets are already up to date and which ones still need to catch up with shared spec changes.
 
-`drift --snapshot` is bookkeeping. It does not prove that the target code matches the spec.
+`drift --snapshot` is bookkeeping. It does not prove that the target code matches the spec, and it will not create a missing target output directory for you.
 
 ## Spec at a glance
 

package/cli/configure-target.ts

@@ -0,0 +1,416 @@
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import YAML from "yaml";
+import { findProjectDir, readManifest } from "../drift/index.js";
+import { ask, askChoice } from "./init.js";
+
+type SupportedTarget = "ios" | "android" | "web";
+
+type WizardOptionPreset = {
+  value: string;
+  generation_value?: string;
+  framework_filter?: string[];
+  dependencies?: string[];
+  extra_generation?: Record<string, any>;
+  refs?: {
+    plugins?: string[];
+    libraries?: string[];
+    packages?: string[];
+    docs?: string[];
+  };
+};
+
+type ChoiceQuestionPreset = {
+  key: string;
+  prompt: string;
+  recommended: string;
+  options: WizardOptionPreset[];
+};
+
+type TargetWizardPreset = {
+  framework: string;
+  framework_prompt?: string;
+  framework_options?: string[];
+  language?: string;
+  min_version?: string;
+  min_sdk?: number;
+  target_sdk?: number;
+  generation_defaults?: Record<string, any>;
+  base_dependencies?: string[];
+  framework_dependencies?: Record<string, string[]>;
+  questions: ChoiceQuestionPreset[];
+};
+
+function readWizardPresets(): Record<SupportedTarget, TargetWizardPreset> {
+  const presetsPath = join(dirname(fileURLToPath(import.meta.url)), "target-presets.json");
+  return JSON.parse(readFileSync(presetsPath, "utf-8")) as Record<SupportedTarget, TargetWizardPreset>;
+}
+
+const TARGET_WIZARDS = readWizardPresets();
+
+function filterOptionsForFramework(
+  question: ChoiceQuestionPreset,
+  framework: string
+): WizardOptionPreset[] {
+  return question.options.filter((option) => {
+    if (!option.framework_filter) return true;
+    return option.framework_filter.includes(framework);
+  });
+}
+
+function effectiveDefault(
+  question: ChoiceQuestionPreset,
+  framework: string,
+  inferred: string | undefined
+): string {
+  if (inferred) return inferred;
+  const filtered = filterOptionsForFramework(question, framework);
+  if (filtered.some((o) => o.value === question.recommended)) return question.recommended;
+  return filtered[0]?.value ?? question.recommended;
+}
+
+function mergeDependencies(
+  derived: string[],
+  existing: unknown,
+  managedDependencies: Set<string>
+): string[] {
+  const extras = Array.isArray(existing)
+    ? existing.filter((dep): dep is string => typeof dep === "string" && !managedDependencies.has(dep))
+    : [];
+  return Array.from(new Set([...derived, ...extras]));
+}
+
+function findOption(question: ChoiceQuestionPreset, value: string): WizardOptionPreset | null {
+  return question.options.find((option) => option.value === value) ?? null;
+}
+
+function collectManagedDependencies(wizard: TargetWizardPreset): Set<string> {
+  const managed = new Set<string>(wizard.base_dependencies ?? []);
+  if (wizard.framework_dependencies) {
+    for (const deps of Object.values(wizard.framework_dependencies)) {
+      for (const dep of deps) managed.add(dep);
+    }
+  }
+  for (const question of wizard.questions) {
+    for (const option of question.options) {
+      for (const dependency of option.dependencies ?? []) {
+        managed.add(dependency);
+      }
+    }
+  }
+  return managed;
+}
+
+function normalizeAndroid(existingPlatform: Record<string, any>): Record<string, string> {
+  const generation = existingPlatform.generation ?? {};
+  const deps = new Set(Array.isArray(generation.dependencies) ? generation.dependencies : []);
+  const architectureValue = typeof generation.architecture === "string" ? generation.architecture.toLowerCase() : "";
+  const stateValue = typeof generation.state === "string" ? generation.state.toLowerCase() : "";
+  const persistenceValue = typeof generation.persistence === "string" ? generation.persistence.toLowerCase() : "";
+  return {
+    architecture:
+      typeof generation.architecture === "string" &&
+      !architectureValue.includes("decompose") &&
+      !architectureValue.includes("compose") &&
+      !deps.has("decompose") &&
+      !deps.has("navigation-compose")
+        ? generation.architecture
+        : architectureValue.includes("decompose") || deps.has("decompose")
+        ? "decompose"
+        : architectureValue.includes("compose") || deps.has("navigation-compose")
+          ? "plain_compose"
+          : "decompose",
+    state:
+      typeof generation.state === "string" &&
+      !stateValue.includes("mvikotlin") &&
+      !stateValue.includes("viewmodel") &&
+      !deps.has("mvikotlin") &&
+      !deps.has("lifecycle-viewmodel-compose")
+        ? generation.state
+        : stateValue.includes("mvikotlin") || deps.has("mvikotlin")
+        ? "mvikotlin"
+        : stateValue.includes("viewmodel") || deps.has("lifecycle-viewmodel-compose")
+          ? "viewmodel"
+          : "mvikotlin",
+    preferences:
+      typeof generation.preferences === "string"
+        ? generation.preferences
+        : persistenceValue === "datastore" || deps.has("datastore-preferences")
+          ? "datastore"
+          : "datastore",
+    database:
+      typeof generation.database === "string"
+        ? generation.database
+        : persistenceValue === "sqldelight" || deps.has("sqldelight")
+          ? "sqldelight"
+          : persistenceValue === "room" || deps.has("room-runtime")
+            ? "room"
+            : "none",
+    di:
+      typeof generation.di === "string"
+        ? ["metro", "koin", "hilt", "none"].includes(generation.di)
+          ? generation.di
+          : generation.di
+        : deps.has("metro")
+          ? "metro"
+          : deps.has("koin-android")
+            ? "koin"
+            : deps.has("hilt-android")
+              ? "hilt"
+              : "metro",
+  };
+}
+
+function normalizeWeb(existingPlatform: Record<string, any>): Record<string, string> {
+  const generation = existingPlatform.generation ?? {};
+  const result: Record<string, string> = {
+    runtime:
+      typeof generation.runtime === "string"
+        ? generation.runtime
+        : "frontend_only",
+    css:
+      typeof generation.css === "string"
+        ? generation.css
+        : "tailwind",
+    storage_backend:
+      typeof generation.storage_backend === "string"
+        ? generation.storage_backend
+        : "none",
+  };
+
+  if (typeof generation.routing === "string") {
+    result.routing = generation.routing.includes("tanstack")
+      ? "tanstack_router"
+      : generation.routing.includes("react-router") || generation.routing === "react_router"
+        ? "react_router"
+        : generation.routing;
+  }
+
+  if (typeof generation.state === "string") {
+    result.state = generation.state === "redux-toolkit"
+      ? "redux"
+      : generation.state === "tanstack-query"
+        ? "query_only"
+        : generation.state;
+  }
+
+  return result;
+}
+
+function normalizeIos(existingPlatform: Record<string, any>): Record<string, string> {
+  const generation = existingPlatform.generation ?? {};
+  const deps = new Set(Array.isArray(generation.dependencies) ? generation.dependencies : []);
+  return {
+    architecture:
+      typeof generation.architecture === "string" &&
+      !generation.architecture.toLowerCase().includes("tca") &&
+      generation.architecture.toLowerCase() !== "native swiftui"
+        ? generation.architecture
+        : typeof generation.architecture === "string" && generation.architecture.toLowerCase().includes("tca")
+        ? "tca_style"
+        : deps.has("swift-composable-architecture")
+          ? "tca_style"
+          : "native",
+    persistence:
+      typeof generation.persistence === "string"
+        ? generation.persistence
+        : deps.has("sqlite")
+          ? "sqlite"
+          : deps.has("swiftdata")
+            ? "swiftdata"
+            : "swiftdata",
+    di:
+      typeof generation.di === "string"
+        ? generation.di
+        : deps.has("factory")
+          ? "factory"
+          : deps.has("custom-di")
+            ? "custom"
+            : "none",
+  };
+}
+
+function normalizeExisting(target: SupportedTarget, existingPlatform: Record<string, any>): Record<string, string> {
+  switch (target) {
+    case "android":
+      return normalizeAndroid(existingPlatform);
+    case "web":
+      return normalizeWeb(existingPlatform);
+    case "ios":
+      return normalizeIos(existingPlatform);
+  }
+}
+
+function buildGeneration(
+  wizard: TargetWizardPreset,
+  answers: Record<string, string>,
+  existingGeneration: Record<string, any>,
+  framework: string
+): Record<string, any> {
+  const generation = {
+    ...(wizard.generation_defaults ?? {}),
+    ...existingGeneration,
+  };
+  const managedDependencies = collectManagedDependencies(wizard);
+  const frameworkDeps = wizard.framework_dependencies?.[framework] ?? [];
+  const derivedDependencies = [...(wizard.base_dependencies ?? []), ...frameworkDeps];
+
+  for (const question of wizard.questions) {
+    const answer = answers[question.key];
+    const selected = answer ? findOption(question, answer) : null;
+    if (!selected) {
+      generation[question.key] = answer || question.recommended;
+      continue;
+    }
+    generation[question.key] = selected.generation_value ?? selected.value;
+    Object.assign(generation, selected.extra_generation ?? {});
+    derivedDependencies.push(...(selected.dependencies ?? []));
+  }
+
+  generation.dependencies = mergeDependencies(
+    derivedDependencies,
+    existingGeneration.dependencies,
+    managedDependencies
+  );
+
+  return generation;
+}
+
+function parseTarget(argv: string[]): SupportedTarget | null {
+  const direct = argv[0];
+  if (direct && ["ios", "android", "web"].includes(direct)) {
+    return direct as SupportedTarget;
+  }
+  const targetIdx = argv.indexOf("--target");
+  if (targetIdx !== -1 && argv[targetIdx + 1] && ["ios", "android", "web"].includes(argv[targetIdx + 1])) {
+    return argv[targetIdx + 1] as SupportedTarget;
+  }
+  return null;
+}
+
+export async function runConfigureTarget(argv: string[]): Promise<void> {
+  const target = parseTarget(argv);
+  const useDefaults = argv.includes("--defaults");
+  const interactive = stdin.isTTY && stdout.isTTY && !useDefaults;
+  if (!target) {
+    console.error("Error: target is required for configure-target");
+    console.error("Usage: openuispec configure-target <ios|android|web> [--defaults]");
+    process.exit(1);
+  }
+
+  if (!interactive && !useDefaults) {
+    console.error(
+      "Error: `openuispec configure-target` needs a TTY for prompts.\n" +
+        "Run with `--defaults` in non-interactive environments."
+    );
+    process.exit(1);
+  }
+
+  const projectDir = findProjectDir(process.cwd());
+  const manifest = readManifest(projectDir);
+  const configuredTargets: string[] = manifest.generation?.targets ?? [];
+  if (configuredTargets.length > 0 && !configuredTargets.includes(target)) {
+    console.error(
+      `Error: target "${target}" is not listed in generation.targets.\n` +
+        `Configured targets: ${configuredTargets.join(", ")}`
+    );
+    process.exit(1);
+  }
+
+  const platformDir = resolve(projectDir, manifest.includes?.platform ?? "./platform/");
+  mkdirSync(platformDir, { recursive: true });
+
+  const platformPath = join(platformDir, `${target}.yaml`);
+  const existingDoc = existsSync(platformPath)
+    ? (YAML.parse(readFileSync(platformPath, "utf-8")) as Record<string, any>)
+    : {};
+  const existingPlatform = existingDoc[target] ?? {};
+  const existingGeneration = existingPlatform.generation ?? {};
+  const wizard = TARGET_WIZARDS[target];
+  const defaultFramework =
+    typeof existingPlatform.framework === "string" && existingPlatform.framework.trim().length > 0
+      ? existingPlatform.framework
+      : wizard.framework;
+  const inferredDefaults = {
+    ...normalizeExisting(target, existingPlatform),
+  };
+
+  let framework = defaultFramework;
+
+  function computeDefaultAnswers(fw: string): Record<string, string> {
+    return Object.fromEntries(
+      wizard.questions.map((question) => {
+        const defaultValue = effectiveDefault(question, fw, inferredDefaults[question.key]);
+        return [question.key, defaultValue];
+      })
+    );
+  }
+
+  let answers = computeDefaultAnswers(framework);
+
+  if (interactive) {
+    const rl = createInterface({ input: stdin, output: stdout });
+
+    try {
+      console.log(`\nOpenUISpec — Configure ${target}\n`);
+      console.log(`Writing target stack choices to ${relative(process.cwd(), platformPath)}\n`);
+
+      const frameworkOptions = [
+        ...(wizard.framework_options ?? [wizard.framework]),
+        "other",
+      ];
+      const chosenFramework = await askChoice(
+        rl,
+        wizard.framework_prompt ?? `${target} framework`,
+        frameworkOptions,
+        framework
+      );
+      framework =
+        chosenFramework === "other"
+          ? await ask(rl, `Custom ${target} framework`, framework)
+          : chosenFramework;
+
+      const defaultAnswers = computeDefaultAnswers(framework);
+      answers = {};
+      for (const question of wizard.questions) {
+        const filtered = filterOptionsForFramework(question, framework);
+        const chosen = await askChoice(
+          rl,
+          question.prompt,
+          [...filtered.map((option) => option.value), "other"],
+          defaultAnswers[question.key]
+        );
+        answers[question.key] =
+          chosen === "other"
+            ? await ask(rl, `Custom value for ${question.key}`, defaultAnswers[question.key])
+            : chosen;
+      }
+    } finally {
+      rl.close();
+    }
+  }
+
+  const updatedPlatform: Record<string, any> = {
+    ...existingPlatform,
+    framework,
+    generation: buildGeneration(wizard, answers, existingGeneration, framework),
+  };
+
+  if (wizard.language) updatedPlatform.language = wizard.language;
+  if (wizard.min_version) updatedPlatform.min_version = existingPlatform.min_version ?? wizard.min_version;
+  if (typeof wizard.min_sdk === "number") updatedPlatform.min_sdk = existingPlatform.min_sdk ?? wizard.min_sdk;
+  if (typeof wizard.target_sdk === "number") {
+    updatedPlatform.target_sdk = existingPlatform.target_sdk ?? wizard.target_sdk;
+  }
+
+  writeFileSync(platformPath, YAML.stringify({ [target]: updatedPlatform }));
+
+  console.log(`\nSaved ${relative(process.cwd(), platformPath)}`);
+  console.log("Configured values:");
+  for (const [key, value] of Object.entries(answers)) {
+    console.log(`  - ${key}: ${value}`);
+  }
+}

package/cli/index.ts

@@ -4,10 +4,12 @@
  *
  * Usage:
  *   openuispec init                           Create a new spec project
+ *   openuispec init --defaults                Scaffold non-interactively with defaults
+ *   openuispec configure-target <t>           Configure target stack and managed dependencies
  *   openuispec drift [--target <t>]           Check for spec drift
  *   openuispec drift --snapshot --target <t>  Snapshot current state + git baseline
  *   openuispec drift --target <t> --explain   Explain semantic changes since baseline
- *   openuispec prepare --target <t>           Build an AI-ready target update bundle
+ *   openuispec prepare --target <t>           Build the target work bundle
  *   openuispec status                         Show cross-target baseline/drift status
  *   openuispec validate [group...]            Validate spec files against schemas
  */
@@ -45,13 +47,19 @@ async function main(): Promise<void> {
 
   switch (command) {
     case "init":
-      await init();
+      await init(rest);
       break;
 
     case "update-rules":
       updateRules();
       break;
 
+    case "configure-target": {
+      const { runConfigureTarget } = await import("./configure-target.js");
+      await runConfigureTarget(rest);
+      break;
+    }
+
     case "drift": {
       const { runDrift } = await import("../drift/index.js");
       runDrift(rest);
@@ -85,11 +93,14 @@ OpenUISpec CLI v0.1
 
 Usage:
   openuispec init                           Create a new spec project
+  openuispec init --defaults                Scaffold non-interactively with defaults
+  openuispec init --no-configure-targets    Skip target stack setup during init
   openuispec update-rules                   Update AI rules to match installed version
+  openuispec configure-target <t> [--defaults] Configure target stack and managed dependencies
   openuispec drift [--target <t>]           Check for spec drift
   openuispec drift --snapshot --target <t>  Snapshot current state + git baseline
   openuispec drift --target <t> --explain   Explain semantic changes since baseline
-  openuispec prepare --target <t>           Build an AI-ready target update bundle
+  openuispec prepare --target <t>           Build the target work bundle
   openuispec status                         Show cross-target baseline/drift status
   openuispec validate [group...]            Validate spec files