anhedral 0.1.10 → 0.4.0

package/dist/architecture/plan.js

@@ -0,0 +1,145 @@
+import { createHash } from 'node:crypto';
+import { DEFAULT_MODULE_REGISTRY, isModuleId, resolveModules, } from './modules.js';
+export const FILE_OWNERSHIP_CLASSES = [
+    'managed',
+    'mergeable',
+    'user',
+];
+export class PlanBuildError extends Error {
+    code;
+    paths;
+    constructor(code, message, paths = []) {
+        super(message);
+        this.code = code;
+        this.paths = paths;
+        this.name = 'PlanBuildError';
+    }
+}
+const OWNERSHIP_SET = new Set(FILE_OWNERSHIP_CLASSES);
+const SHA256_PATTERN = /^[a-f0-9]{64}$/;
+function compareStrings(left, right) {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+}
+export function isFileOwnershipClass(value) {
+    return typeof value === 'string' && OWNERSHIP_SET.has(value);
+}
+export function isSha256(value) {
+    return typeof value === 'string' && SHA256_PATTERN.test(value);
+}
+/**
+ * Hash rendered text or exact filesystem bytes.
+ *
+ * Strings are encoded as UTF-8 for deterministic generation-plan fingerprints.
+ * Callers hashing an existing file must pass its Buffer/Uint8Array so malformed
+ * byte sequences cannot collapse to the same Unicode replacement characters.
+ */
+export function hashContent(content) {
+    const hash = createHash('sha256');
+    if (typeof content === 'string')
+        hash.update(content, 'utf8');
+    else
+        hash.update(content);
+    return hash.digest('hex');
+}
+export function writePolicyForOwnership(ownership) {
+    switch (ownership) {
+        case 'managed': return 'replace-if-unmodified';
+        case 'mergeable': return 'structural-merge';
+        case 'user': return 'create-only';
+    }
+}
+export function normalizePlanPath(value) {
+    if (typeof value !== 'string') {
+        throw new PlanBuildError('INVALID_PLAN_PATH', `Plan paths must be strings: ${String(value)}`, Object.freeze([String(value)]));
+    }
+    const pathValue = value.trim();
+    if (pathValue.length === 0
+        || pathValue !== value
+        || pathValue === '.'
+        || pathValue.startsWith('/')
+        || /^[a-zA-Z]:\//.test(pathValue)
+        || pathValue.includes('\\')
+        || pathValue.includes('\0')) {
+        throw new PlanBuildError('INVALID_PLAN_PATH', `Plan paths must be non-empty relative POSIX paths: ${JSON.stringify(value)}`, Object.freeze([value]));
+    }
+    const segments = pathValue.split('/');
+    if (segments.some((segment) => segment.length === 0 || segment === '.' || segment === '..')) {
+        throw new PlanBuildError('INVALID_PLAN_PATH', `Plan paths cannot contain empty, current-directory, or parent-directory segments: ${JSON.stringify(value)}`, Object.freeze([value]));
+    }
+    return segments.join('/');
+}
+function normalizeOwner(value) {
+    if (value === 'root' || isModuleId(value))
+        return value;
+    throw new PlanBuildError('INVALID_FILE_OWNER', `Unknown plan contribution owner: ${String(value)}`);
+}
+function canonicalFingerprintPayload(operation, requestedModules, resolvedModules, dependencyAddedModules, dependencyEdges, files) {
+    return JSON.stringify({
+        planVersion: 1,
+        operation,
+        requestedModules,
+        resolvedModules,
+        dependencyAddedModules,
+        dependencyEdges,
+        files: files.map((file) => ({
+            path: file.path,
+            owner: file.owner,
+            ownership: file.ownership,
+            writePolicy: file.writePolicy,
+            contentHash: file.contentHash,
+        })),
+    });
+}
+export function buildGenerationPlan(input) {
+    if (!['init', 'add'].includes(input.operation)) {
+        throw new PlanBuildError('INVALID_OPERATION', `Unknown generation operation: ${String(input.operation)}`);
+    }
+    const registry = input.registry ?? DEFAULT_MODULE_REGISTRY;
+    const resolution = resolveModules(input.requestedModules, registry);
+    const resolvedSet = new Set(resolution.resolvedModules);
+    const plannedByPath = new Map();
+    for (const contribution of input.contributions ?? []) {
+        const owner = normalizeOwner(contribution.module);
+        if (owner !== 'root' && !resolvedSet.has(owner)) {
+            throw new PlanBuildError('UNRESOLVED_CONTRIBUTION', `Module ${owner} contributed files but is not in the resolved module plan`);
+        }
+        for (const file of contribution.files) {
+            const filePath = normalizePlanPath(file.path);
+            if (typeof file.content !== 'string') {
+                throw new PlanBuildError('INVALID_FILE_CONTENT', `Planned file content must be a string: ${filePath}`, Object.freeze([filePath]));
+            }
+            if (!isFileOwnershipClass(file.ownership)) {
+                throw new PlanBuildError('INVALID_FILE_OWNERSHIP', `Unknown ownership class for ${filePath}: ${String(file.ownership)}`, Object.freeze([filePath]));
+            }
+            const existing = plannedByPath.get(filePath);
+            if (existing) {
+                throw new PlanBuildError('DUPLICATE_OUTPUT_PATH', `Output path ${filePath} is owned by both ${existing.owner} and ${owner}; compose it before planning`, Object.freeze([filePath]));
+            }
+            const plannedFile = Object.freeze({
+                path: filePath,
+                owner,
+                ownership: file.ownership,
+                writePolicy: writePolicyForOwnership(file.ownership),
+                content: file.content,
+                contentHash: hashContent(file.content),
+            });
+            plannedByPath.set(filePath, plannedFile);
+        }
+    }
+    const files = Object.freeze([...plannedByPath.values()].sort((left, right) => compareStrings(left.path, right.path)));
+    const fingerprint = hashContent(canonicalFingerprintPayload(input.operation, resolution.requestedModules, resolution.resolvedModules, resolution.dependencyAddedModules, resolution.dependencyEdges, files));
+    return Object.freeze({
+        planVersion: 1,
+        operation: input.operation,
+        requestedModules: resolution.requestedModules,
+        resolvedModules: resolution.resolvedModules,
+        dependencyAddedModules: resolution.dependencyAddedModules,
+        dependencyEdges: resolution.dependencyEdges,
+        files,
+        fingerprint,
+    });
+}

package/dist/architecture/templates.d.ts

@@ -0,0 +1,10 @@
+import type { ModuleId } from './modules.js';
+export declare const TEMPLATE_IDS: readonly ["web-next", "mobile-expo", "api-fastify", "desktop-electron", "extension-wxt", "db-drizzle"];
+export type TemplateId = (typeof TEMPLATE_IDS)[number];
+export type TemplateProvenance = {
+    readonly version: number;
+    readonly sha256: string;
+};
+export type TemplateProvenanceMap = Readonly<Partial<Record<TemplateId, TemplateProvenance>>>;
+export declare function isTemplateId(value: unknown): value is TemplateId;
+export declare function templateIdsForModules(modules: readonly ModuleId[]): readonly TemplateId[];

package/dist/architecture/templates.js

@@ -0,0 +1,23 @@
+export const TEMPLATE_IDS = [
+    'web-next',
+    'mobile-expo',
+    'api-fastify',
+    'desktop-electron',
+    'extension-wxt',
+    'db-drizzle',
+];
+const TEMPLATE_ID_SET = new Set(TEMPLATE_IDS);
+export function isTemplateId(value) {
+    return typeof value === 'string' && TEMPLATE_ID_SET.has(value);
+}
+export function templateIdsForModules(modules) {
+    const selected = new Set(modules);
+    return Object.freeze([
+        selected.has('web') ? 'web-next' : null,
+        selected.has('mobile') ? 'mobile-expo' : null,
+        selected.has('api') ? 'api-fastify' : null,
+        selected.has('desktop') ? 'desktop-electron' : null,
+        selected.has('extension') ? 'extension-wxt' : null,
+        selected.has('db') ? 'db-drizzle' : null,
+    ].filter((id) => id !== null));
+}

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin.js

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+import { createInterface } from 'node:readline/promises';
+import { argv, stdin, stdout } from 'node:process';
+import { buildAddOptions, buildOptions, buildOptionsForRoot, parseCli, parseNewProjectRequest, parseUiAddOptions, USAGE } from './cli.js';
+import { doctorProject, scaffoldAddModules, scaffoldProject, scaffoldUiComponents, scaffoldUpgradeProject } from './scaffold.js';
+import { DEFAULT_PROMPT_APP_MODULES, DEFAULT_PROMPT_FEATURE_MODULES, hasUiSelection, parsePromptModules, shouldPromptForInitModules, } from './prompts.js';
+import { GENERATOR_VERSION } from './version.js';
+import { PostCommitError } from './transaction.js';
+function writeCliError(error, code, json) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (json)
+        console.error(JSON.stringify({ error: message, code }));
+    else
+        console.error('Error:', message);
+}
+function splitAddArgs(args) {
+    const moduleNames = [];
+    const flagArgs = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === '--toolchain') {
+            flagArgs.push(arg);
+            if (args[index + 1] != null) {
+                flagArgs.push(args[index + 1]);
+                index += 1;
+            }
+            continue;
+        }
+        if (arg.startsWith('--')) {
+            flagArgs.push(arg);
+            continue;
+        }
+        moduleNames.push(arg);
+    }
+    return { moduleNames, flagArgs };
+}
+async function promptForInitModules(args) {
+    if (!shouldPromptForInitModules(args, stdin.isTTY === true))
+        return args;
+    const rl = createInterface({ input: stdin, output: stdout });
+    try {
+        console.log('Select app surfaces: web, mobile, api, desktop, extension');
+        const appAnswer = await rl.question('App surfaces [all]: ');
+        console.log('Select backend features: db, auth, billing, storage, native-subscriptions, electron-updater');
+        const featureAnswer = await rl.question('Backend features [all]: ');
+        const selected = [
+            ...parsePromptModules(appAnswer, DEFAULT_PROMPT_APP_MODULES),
+            ...parsePromptModules(featureAnswer, DEFAULT_PROMPT_FEATURE_MODULES),
+        ];
+        const result = [...args, ...selected.map((moduleName) => `--${moduleName}`)];
+        const hasUiClient = selected.some((moduleName) => ['web', 'mobile', 'desktop', 'extension'].includes(moduleName));
+        if (hasUiClient && !hasUiSelection(args)) {
+            console.log('Optionally add starter UI components to each selected client.');
+            const componentAnswer = await rl.question('Starter components [none]: ');
+            if (componentAnswer.trim())
+                result.push(`--ui=${componentAnswer}`);
+        }
+        if (selected.includes('mobile') && !args.some((arg) => arg.startsWith('--native-styling'))) {
+            const stylingAnswer = (await rl.question('Expo styling [nativewind]: ')).trim();
+            result.push(`--native-styling=${stylingAnswer || 'nativewind'}`);
+        }
+        return result;
+    }
+    finally {
+        rl.close();
+    }
+}
+async function main() {
+    const args = argv.slice(2);
+    const command = args[0];
+    const rawArgs = args.slice(1);
+    const json = rawArgs.includes('--json');
+    const verbose = rawArgs.includes('--verbose');
+    if (json)
+        process.env.ANHEDRAL_QUIET = '1';
+    if (verbose)
+        process.env.ANHEDRAL_VERBOSE = '1';
+    if (command === '--version' || command === '-v') {
+        if (json)
+            console.log(JSON.stringify({ version: GENERATOR_VERSION }));
+        else
+            console.log(GENERATOR_VERSION);
+        return;
+    }
+    if (!command || command === '--help' || command === '-h') {
+        if (json)
+            console.log(JSON.stringify({ usage: USAGE }));
+        else
+            console.log(USAGE);
+        return;
+    }
+    if (!['new', 'init', 'add', 'ui', 'upgrade', 'doctor'].includes(command)) {
+        if (json)
+            writeCliError(new Error(`Unknown command: ${command}`), 'UNKNOWN_COMMAND', true);
+        else {
+            console.error(`Unknown command: ${command}`);
+            console.log(USAGE);
+        }
+        process.exitCode = 1;
+        return;
+    }
+    if (rawArgs.includes('--help') || rawArgs.includes('-h')) {
+        if (json)
+            console.log(JSON.stringify({ usage: USAGE }));
+        else
+            console.log(USAGE);
+        return;
+    }
+    let phase = 'arguments';
+    try {
+        if (command === 'new') {
+            const request = parseNewProjectRequest(rawArgs);
+            const promptedArgs = await promptForInitModules([...request.moduleArgs]);
+            const options = buildOptionsForRoot(parseCli(promptedArgs), request.directory);
+            phase = 'execute';
+            await scaffoldProject(options);
+            if (!options.json && !options.dryRun) {
+                console.log(`\nCreated ${options.rootDirectory}\nNext: cd ${options.rootDirectory}\nThen follow README.md to configure the selected providers and start the app.`);
+            }
+        }
+        else if (command === 'doctor') {
+            const unknown = rawArgs.filter((arg) => !['--json', '--verbose'].includes(arg));
+            if (unknown.length)
+                throw new Error(`Unknown doctor option: ${unknown[0]}`);
+            phase = 'execute';
+            const report = doctorProject();
+            if (json)
+                console.log(JSON.stringify(report, null, 2));
+            else {
+                console.log(report.ok ? 'Anhedral project is healthy.' : 'Anhedral project has drift.');
+                for (const issue of report.issues)
+                    console.log(`  ${issue.severity}: ${issue.path}: ${issue.message}`);
+            }
+            if (!report.ok)
+                process.exitCode = 1;
+        }
+        else if (command === 'add') {
+            const { moduleNames, flagArgs } = splitAddArgs(rawArgs);
+            const options = buildAddOptions(moduleNames, parseCli(flagArgs));
+            phase = 'execute';
+            await scaffoldAddModules(options);
+        }
+        else if (command === 'ui') {
+            if (rawArgs[0] !== 'add')
+                throw new Error('Unknown UI command. Use: anhedral ui add <component...>');
+            const options = parseUiAddOptions(rawArgs.slice(1));
+            phase = 'execute';
+            await scaffoldUiComponents(options);
+        }
+        else if (command === 'upgrade') {
+            const unknown = rawArgs.filter((arg) => !['--skip-install', '--dry-run', '--json', '--verbose'].includes(arg));
+            if (unknown.length)
+                throw new Error(`Unknown upgrade option: ${unknown[0]}`);
+            phase = 'execute';
+            await scaffoldUpgradeProject({
+                skipInstall: rawArgs.includes('--skip-install'),
+                dryRun: rawArgs.includes('--dry-run'),
+                json,
+            });
+        }
+        else {
+            const options = buildOptions(parseCli(await promptForInitModules(rawArgs)));
+            phase = 'execute';
+            await scaffoldProject(options);
+        }
+    }
+    catch (error) {
+        const code = error instanceof PostCommitError
+            ? 'POST_COMMIT_FAILED'
+            : phase === 'arguments'
+                ? 'INVALID_ARGUMENT'
+                : command === 'doctor'
+                    ? 'DOCTOR_FAILED'
+                    : 'GENERATION_FAILED';
+        writeCliError(error, code, json);
+        process.exitCode = 1;
+    }
+}
+void main();

package/dist/cli.d.ts

@@ -1,10 +1,32 @@
-import type { InitOptions } from './scaffold.js';
-export declare const USAGE = "\nanhedral init [--toolchain <latest|stable>] [--skip-install]\n\nCommands:\n  anhedral init\n    Expo + React Native Reusables, Fastify, WXT extension, Neon + Drizzle, Cloudflare R2/CDN, Clerk, RevenueCat + Stripe, Vercel\n";
+import type { AddOptions, InitOptions } from './scaffold.js';
+import { type NativeStylingLibrary } from './ui.js';
+import type { UiAddOptions } from './scaffold.js';
+export declare const USAGE = "\nanhedral new <directory> [modules...] [--ui <components>] [--native-styling <nativewind|uniwind>] [--toolchain <latest|stable>] [--skip-install] [--dry-run] [--json] [--verbose]\nanhedral init [modules...] [--ui <components>] [--native-styling <nativewind|uniwind>] [--toolchain <latest|stable>] [--skip-install] [--dry-run] [--json] [--verbose]\nanhedral add <module...> [--skip-install] [--dry-run] [--json] [--verbose]\nanhedral ui add <component...> [--target <client>] [--skip-install] [--dry-run] [--json] [--verbose]\nanhedral upgrade [--skip-install] [--dry-run] [--json] [--verbose]\nanhedral doctor [--json] [--verbose]\nanhedral --version\n\nCommands:\n  anhedral new my-app\n    Generate the complete TypeScript stack in a new directory. With no module flags, every module is included.\n  anhedral new my-app --web --api --db --auth\n    Generate a web app, Fastify API, shared database package, and auth wiring.\n  anhedral init --web --api --db --auth\n    Generate the same readable workspace in the current empty directory.\n  anhedral add mobile extension\n    Add missing modules to an existing Anhedral project.\n  anhedral ui add button dialog --target mobile\n    Add React Native Reusables components to Expo. DOM clients use shadcn/ui.\n  anhedral upgrade\n    Transactionally upgrade a supported older Anhedral project before adding modules.\n";
+export type NewProjectRequest = {
+    readonly directory: string;
+    readonly moduleArgs: readonly string[];
+};
+export declare function parseNewProjectRequest(args: readonly string[]): NewProjectRequest;
+export declare const APP_MODULES: readonly ["web", "mobile", "api", "desktop", "extension"];
+export declare const FEATURE_MODULES: readonly ["db", "auth", "billing", "storage", "native-subscriptions", "electron-updater"];
+export type AppModule = (typeof APP_MODULES)[number];
+export type FeatureModule = (typeof FEATURE_MODULES)[number];
+export type SupportedModule = AppModule | FeatureModule;
 export type ParsedFlags = {
     toolchain?: string;
     skipInstall?: boolean;
+    dryRun?: boolean;
+    json?: boolean;
+    verbose?: boolean;
+    uiComponents: string[];
+    nativeStyling?: NativeStylingLibrary;
+    modules: Set<SupportedModule>;
 };
 export declare function parseCli(args: string[]): ParsedFlags;
+export declare function normalizeModuleName(raw: string): SupportedModule | null;
 export declare function deriveProjectName(cwd: string): string;
 export declare function deriveDisplayName(cwd: string): string;
 export declare function buildOptions(flags: ParsedFlags): InitOptions;
+export declare function buildOptionsForRoot(flags: ParsedFlags, root: string): InitOptions;
+export declare function parseUiAddOptions(args: readonly string[]): UiAddOptions;
+export declare function buildAddOptions(modules: string[], flags: ParsedFlags): AddOptions;

package/dist/cli.js

@@ -1,24 +1,95 @@
 import path from 'node:path';
 import { env } from 'node:process';
 import { TOOLCHAIN_CHANNELS, resolveToolchainChannel } from './toolchain.js';
+import { resolveModules } from './architecture/modules.js';
+import { packageNameFromText } from './render.js';
+import { isNativeStylingLibrary, isUiTarget, parseUiComponentList, } from './ui.js';
 export const USAGE = `
-anhedral init [--toolchain <latest|stable>] [--skip-install]
+anhedral new <directory> [modules...] [--ui <components>] [--native-styling <nativewind|uniwind>] [--toolchain <latest|stable>] [--skip-install] [--dry-run] [--json] [--verbose]
+anhedral init [modules...] [--ui <components>] [--native-styling <nativewind|uniwind>] [--toolchain <latest|stable>] [--skip-install] [--dry-run] [--json] [--verbose]
+anhedral add <module...> [--skip-install] [--dry-run] [--json] [--verbose]
+anhedral ui add <component...> [--target <client>] [--skip-install] [--dry-run] [--json] [--verbose]
+anhedral upgrade [--skip-install] [--dry-run] [--json] [--verbose]
+anhedral doctor [--json] [--verbose]
+anhedral --version
 
 Commands:
-  anhedral init
-    Expo + React Native Reusables, Fastify, WXT extension, Neon + Drizzle, Cloudflare R2/CDN, Clerk, RevenueCat + Stripe, Vercel
+  anhedral new my-app
+    Generate the complete TypeScript stack in a new directory. With no module flags, every module is included.
+  anhedral new my-app --web --api --db --auth
+    Generate a web app, Fastify API, shared database package, and auth wiring.
+  anhedral init --web --api --db --auth
+    Generate the same readable workspace in the current empty directory.
+  anhedral add mobile extension
+    Add missing modules to an existing Anhedral project.
+  anhedral ui add button dialog --target mobile
+    Add React Native Reusables components to Expo. DOM clients use shadcn/ui.
+  anhedral upgrade
+    Transactionally upgrade a supported older Anhedral project before adding modules.
 `;
+export function parseNewProjectRequest(args) {
+    const [directory, ...moduleArgs] = args;
+    if (!directory || directory.startsWith('--'))
+        throw new Error('anhedral new requires a destination directory before module flags');
+    return Object.freeze({ directory, moduleArgs: Object.freeze(moduleArgs) });
+}
+export const APP_MODULES = ['web', 'mobile', 'api', 'desktop', 'extension'];
+export const FEATURE_MODULES = ['db', 'auth', 'billing', 'storage', 'native-subscriptions', 'electron-updater'];
 export function parseCli(args) {
-    const flags = {};
+    const flags = { modules: new Set(), uiComponents: [] };
     for (let index = 0; index < args.length; index += 1) {
         const token = args[index];
         if (!token.startsWith('--')) {
-            throw new Error(`Unexpected argument: ${token}. Use flags: --toolchain, --skip-install`);
+            const moduleName = normalizeModuleName(token);
+            if (moduleName) {
+                flags.modules.add(moduleName);
+                continue;
+            }
+            throw new Error(`Unexpected argument: ${token}. Use module names, module flags, --toolchain, or --skip-install`);
         }
         if (token === '--skip-install') {
             flags.skipInstall = true;
             continue;
         }
+        if (token === '--dry-run') {
+            flags.dryRun = true;
+            continue;
+        }
+        if (token === '--json') {
+            flags.json = true;
+            continue;
+        }
+        if (token === '--verbose') {
+            flags.verbose = true;
+            continue;
+        }
+        if (token === '--ui') {
+            const value = args[index + 1];
+            if (!value || value.startsWith('--'))
+                throw new Error('Missing value for --ui');
+            flags.uiComponents.push(...parseUiComponentList(value));
+            index += 1;
+            continue;
+        }
+        if (token.startsWith('--ui=')) {
+            flags.uiComponents.push(...parseUiComponentList(token.slice('--ui='.length)));
+            continue;
+        }
+        if (token === '--native-styling') {
+            const value = args[index + 1];
+            if (!isNativeStylingLibrary(value))
+                throw new Error('--native-styling must be nativewind or uniwind');
+            flags.nativeStyling = value;
+            index += 1;
+            continue;
+        }
+        if (token.startsWith('--native-styling=')) {
+            const value = token.slice('--native-styling='.length);
+            if (!isNativeStylingLibrary(value))
+                throw new Error('--native-styling must be nativewind or uniwind');
+            flags.nativeStyling = value;
+            continue;
+        }
         if (token === '--toolchain') {
             const value = args[index + 1];
             if (!value || value.startsWith('--')) {
@@ -28,40 +99,137 @@ export function parseCli(args) {
             index += 1;
             continue;
         }
+        if (token.startsWith('--toolchain=')) {
+            const value = token.slice('--toolchain='.length);
+            if (!value) {
+                throw new Error('Missing value for --toolchain');
+            }
+            flags.toolchain = value;
+            continue;
+        }
+        const moduleName = normalizeModuleName(token.slice(2));
+        if (moduleName) {
+            flags.modules.add(moduleName);
+            continue;
+        }
         throw new Error(`Unknown flag: ${token}`);
     }
     return flags;
 }
+export function normalizeModuleName(raw) {
+    if (APP_MODULES.includes(raw))
+        return raw;
+    if (FEATURE_MODULES.includes(raw))
+        return raw;
+    return null;
+}
 export function deriveProjectName(cwd) {
-    const base = path.basename(cwd);
-    const sanitized = base
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9_-]+/g, '-')
-        .replace(/^-+|-+$/g, '');
-    return sanitized || 'anhedral-app';
+    return packageNameFromText(path.basename(cwd));
 }
 export function deriveDisplayName(cwd) {
     const base = path.basename(cwd).trim();
     return base || 'Anhedral App';
 }
 export function buildOptions(flags) {
-    const cwd = process.cwd();
-    const projectName = deriveProjectName(cwd);
-    const displayName = deriveDisplayName(cwd);
+    return buildOptionsForRoot(flags, process.cwd());
+}
+export function buildOptionsForRoot(flags, root) {
+    const resolvedRoot = path.resolve(root);
+    const projectName = deriveProjectName(resolvedRoot);
+    const displayName = deriveDisplayName(resolvedRoot);
     if (flags.toolchain != null && !TOOLCHAIN_CHANNELS.includes(flags.toolchain)) {
         throw new Error(`--toolchain must be one of: ${TOOLCHAIN_CHANNELS.join(', ')}`);
     }
+    const requestedModules = flags.modules.size === 0
+        ? [...APP_MODULES, ...FEATURE_MODULES]
+        : [...flags.modules];
+    const resolution = resolveModules(requestedModules);
     return {
         projectName,
         displayName,
-        auth: 'clerk',
-        payments: 'revenuecat_stripe',
-        db: 'neon',
-        orm: 'drizzle',
-        storage: 'r2',
-        api: 'fastify',
+        modules: [...resolution.requestedModules],
+        uiComponents: Array.from(new Set(flags.uiComponents)),
+        nativeStyling: flags.nativeStyling ?? 'nativewind',
         skipInstall: flags.skipInstall === true || env.ANHEDRAL_SKIP_INSTALL === '1',
+        dryRun: flags.dryRun === true,
+        json: flags.json === true,
         toolchainChannel: resolveToolchainChannel(flags.toolchain ?? env.ANHEDRAL_TOOLCHAIN),
+        rootDirectory: resolvedRoot,
+    };
+}
+export function parseUiAddOptions(args) {
+    const components = [];
+    const targets = [];
+    let skipInstall = env.ANHEDRAL_SKIP_INSTALL === '1';
+    let dryRun = false;
+    let json = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const token = args[index];
+        if (!token.startsWith('--')) {
+            components.push(...parseUiComponentList(token));
+            continue;
+        }
+        if (token === '--target') {
+            const value = args[index + 1];
+            if (!isUiTarget(value))
+                throw new Error(`--target must be one of: web, mobile, desktop, extension`);
+            targets.push(value);
+            index += 1;
+            continue;
+        }
+        if (token.startsWith('--target=')) {
+            const value = token.slice('--target='.length);
+            if (!isUiTarget(value))
+                throw new Error(`--target must be one of: web, mobile, desktop, extension`);
+            targets.push(value);
+            continue;
+        }
+        if (token === '--skip-install') {
+            skipInstall = true;
+            continue;
+        }
+        if (token === '--dry-run') {
+            dryRun = true;
+            continue;
+        }
+        if (token === '--json') {
+            json = true;
+            continue;
+        }
+        if (token === '--verbose') {
+            continue;
+        }
+        throw new Error(`Unknown UI option: ${token}`);
+    }
+    if (components.length === 0)
+        throw new Error('anhedral ui add requires at least one component');
+    return {
+        components: Array.from(new Set(components)),
+        targets: Array.from(new Set(targets)),
+        skipInstall,
+        dryRun,
+        json,
+    };
+}
+export function buildAddOptions(modules, flags) {
+    const requestedModules = [...modules, ...flags.modules];
+    if (requestedModules.length === 0) {
+        throw new Error('anhedral add requires at least one module');
+    }
+    const normalizedModules = requestedModules.map((moduleName) => {
+        const normalized = normalizeModuleName(moduleName);
+        if (!normalized) {
+            throw new Error(`Unknown module: ${moduleName}`);
+        }
+        return normalized;
+    });
+    return {
+        modules: Array.from(new Set(normalizedModules)),
+        skipInstall: flags.skipInstall === true || env.ANHEDRAL_SKIP_INSTALL === '1',
+        dryRun: flags.dryRun === true,
+        json: flags.json === true,
+        ...((flags.toolchain ?? env.ANHEDRAL_TOOLCHAIN) != null
+            ? { toolchainChannel: resolveToolchainChannel(flags.toolchain ?? env.ANHEDRAL_TOOLCHAIN) }
+            : {}),
     };
 }

package/dist/composers/root.d.ts

@@ -0,0 +1,6 @@
+import type { CompositionModel } from '../architecture/contributions.js';
+export type RootEnvironmentContext = {
+    readonly corsOrigins: readonly string[];
+};
+export declare function composeRootEnvironment(model: CompositionModel, context: RootEnvironmentContext): readonly string[];
+export declare function composeVercelCrons(model: CompositionModel): readonly Record<string, string>[];