anhedral 0.8.6 → 0.10.0

package/dist/registry/add.js

@@ -0,0 +1,163 @@
+import { configureSecurityBackports } from '../security-backports.js';
+import { bootstrapWorkspace } from '../scaffold/bootstrap.js';
+import { registerApplication } from '../project-state.js';
+import { registerVercelApplication } from '../vercel.js';
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import path from 'node:path';
+import { isDeepStrictEqual } from 'node:util';
+import { applyEdits, modify, parse } from 'jsonc-parser';
+import { STANDARD_PRODUCTS, installStackItem } from '../stack-registry.js';
+import { inspectProject, validateSetupPlan } from '../readiness.js';
+import { GENERATOR_VERSION } from '../version.js';
+import { runStagedTransaction } from '../transaction.js';
+import { inspectWorkspaceGraph } from '../workspace-graph.js';
+import { execFile } from '../util.js';
+import { json, put, readJson } from '../scaffold/files.js';
+import { writeStandardRoot } from '../scaffold/workspace.js';
+import { createRecipeContext } from './context.js';
+import { resolveStackRegistry, resolveStandardProducts } from './resolve.js';
+import { sourceFiles } from './receipt.js';
+/** Add recipes to an initialized workspace, refusing edits to customer-owned source. */
+export async function addStackItems(root, request, run = execFile) {
+    for (const key of Object.keys(request))
+        if (!['items', 'dryRun', 'skipInstall'].includes(key))
+            throw new Error(`Unknown add option: ${key}. Only bundled registry items are supported.`);
+    root = realpathSync(root);
+    if (!request.items.length)
+        throw new Error('Select at least one registry item.');
+    const plan = readJson(root, 'anhedral.setup.json');
+    validateSetupPlan(plan);
+    if (plan.cliVersion !== GENERATOR_VERSION)
+        throw new Error('Use the project CLI version before adding recipes.');
+    if (!inspectProject(root).localReady)
+        throw new Error('Run doctor and resolve project provenance or workspace errors before add.');
+    const receipt = readJson(root, 'anhedral.registry.json');
+    if (!receipt.files || typeof receipt.files !== 'object' || Array.isArray(receipt.files))
+        throw new Error('This project has no scaffold fingerprints; migrate it deliberately before using add.');
+    const baseline = receipt.files;
+    const selected = new Set(plan.products);
+    for (const id of request.items) {
+        if (!STANDARD_PRODUCTS.includes(id))
+            throw new Error(`Unknown stack product: ${id}.`);
+        selected.add(id);
+    }
+    resolveStandardProducts(selected, plan.hosting, false);
+    const options = {
+        root,
+        name: plan.name ?? path.basename(root),
+        products: [...selected].sort(),
+        hosting: plan.hosting,
+        skipInstall: !!request.skipInstall,
+        dryRun: false,
+        json: true,
+        initializeGit: false,
+    };
+    const registry = resolveStackRegistry(options);
+    const oldItems = new Map(plan.registry.items.map((item) => [item.name, item]));
+    const recipes = registry.items.filter((item) => item.installer === 'recipe' && !isDeepStrictEqual(oldItems.get(item.name), item));
+    // Relocating auth, database or service ownership requires a migration, not an additive scaffold.
+    for (const item of registry.items) {
+        const before = oldItems.get(item.name);
+        if (before && before.targets.some((target) => !item.targets.includes(target)))
+            throw new Error(`Adding this selection relocates ${item.name}; migrate its existing source explicitly.`);
+    }
+    const before = sourceFiles(root);
+    const receiptText = readFileSync(path.join(root, 'anhedral.registry.json'), 'utf8');
+    const commitPaths = [];
+    const conflicts = [];
+    const result = {
+        schemaVersion: 1,
+        root,
+        dryRun: !!request.dryRun,
+        items: registry.items
+            .filter((item) => !isDeepStrictEqual(oldItems.get(item.name), item))
+            .map((item) => item.name),
+        bootstrapRequired: recipes.some((item) => ['vinext', 'next'].includes(item.name)) &&
+            !existsSync(path.join(root, 'apps/web/package.json')),
+        filesChecked: true,
+        targets: recipes.flatMap((item) => item.targets),
+        files: commitPaths,
+        conflicts,
+    };
+    // The upstream web generator requires network access and executes package scripts.
+    // A preview reports the resolved selection without invoking that generator.
+    if (request.dryRun && result.bootstrapRequired) {
+        result.filesChecked = false;
+        return result;
+    }
+    await runStagedTransaction(root, {
+        dryRun: !!request.dryRun,
+        commitPaths,
+        seedPaths: [...before.keys(), 'anhedral.registry.json'],
+        build: async (stage) => {
+            const context = createRecipeContext(stage, options);
+            for (const item of registry.items)
+                Object.assign(context.bindings, item.bindings);
+            if (recipes.some((item) => ['vinext', 'next'].includes(item.name)) &&
+                !existsSync(path.join(stage, 'apps/web/package.json')))
+                bootstrapWorkspace(stage, options.name, run, true);
+            for (const item of recipes)
+                await installStackItem(item, context);
+            // Configuration items affect the existing runtime without regenerating its application source.
+            const configurationItems = registry.items.filter((item) => !isDeepStrictEqual(oldItems.get(item.name), item) && item.bindings);
+            if (configurationItems.length) {
+                const file = `apps/${context.runtimeApp}/wrangler.jsonc`;
+                let content = readFileSync(path.join(stage, file), 'utf8');
+                const config = parse(content);
+                for (const item of configurationItems)
+                    for (const [key, value] of Object.entries(item.bindings)) {
+                        if (config[key] !== undefined && !isDeepStrictEqual(config[key], value))
+                            throw new Error(`Existing ${key} configuration conflicts with ${item.name}; configure it explicitly.`);
+                        content = applyEdits(content, modify(content, [key], value, {
+                            formattingOptions: { insertSpaces: true, tabSize: 2 },
+                        }));
+                    }
+                put(stage, file, content);
+            }
+            writeStandardRoot(stage, options, registry, true);
+            if (options.products.includes('next') && options.hosting === 'vercel')
+                registerVercelApplication(stage);
+            if ([...sourceFiles(stage).keys()].some((file) => /^apps\/[^/]+\/wrangler\.jsonc$/.test(file)))
+                registerApplication(stage, true);
+            if (!request.dryRun)
+                run('pnpm', ['install', '--lockfile-only', '--no-frozen-lockfile', '--ignore-scripts'], stage);
+            if (!request.dryRun && configureSecurityBackports(stage))
+                run('pnpm', ['install', '--lockfile-only', '--no-frozen-lockfile', '--ignore-scripts'], stage);
+            const after = sourceFiles(stage);
+            const files = { ...baseline };
+            for (const [file, hash] of after) {
+                if (before.get(file) === hash)
+                    continue;
+                if (before.has(file) &&
+                    baseline[file] !== before.get(file) &&
+                    file !== 'anhedral.project.json')
+                    conflicts.push(file);
+                commitPaths.push(file);
+                files[file] = hash;
+            }
+            // Never delete preexisting source as a side effect of an addition.
+            for (const file of before.keys())
+                if (!after.has(file))
+                    conflicts.push(file);
+            if (conflicts.length && !request.dryRun)
+                throw new Error(`Addition conflicts with edited or untracked source: ${conflicts.join(', ')}. No files were installed.`);
+            json(stage, 'anhedral.registry.json', {
+                ...registry,
+                status: 'scaffolded',
+                resourcesProvisioned: false,
+                workspaces: inspectWorkspaceGraph(stage),
+                files,
+            });
+            commitPaths.push('anhedral.registry.json');
+            // Detect concurrent changes even to source that this addition would otherwise preserve.
+            if (!isDeepStrictEqual(sourceFiles(root), before) ||
+                readFileSync(path.join(root, 'anhedral.registry.json'), 'utf8') !== receiptText)
+                throw new Error('Workspace changed during addition; retry after reviewing source.');
+        },
+        afterCommit: () => {
+            if (!request.skipInstall)
+                run('pnpm', ['install', '--frozen-lockfile'], root);
+        },
+    });
+    return result;
+}

package/dist/registry/bootstrap.d.ts

@@ -0,0 +1,2 @@
+export declare const BOOTSTRAP_COMMAND: readonly ["pnpm", "dlx", "shadcn@4.21.4", "init", "--monorepo", "--template", "next"];
+export declare function bootstrapArguments(name: string, cwd: string): string[];

package/dist/registry/bootstrap.js

@@ -0,0 +1,14 @@
+import { SHADCN_VERSION } from '../dependencies.js';
+const SHADCN_PACKAGE = `shadcn@${SHADCN_VERSION}`;
+export const BOOTSTRAP_COMMAND = [
+    'pnpm',
+    'dlx',
+    SHADCN_PACKAGE,
+    'init',
+    '--monorepo',
+    '--template',
+    'next',
+];
+export function bootstrapArguments(name, cwd) {
+    return [...BOOTSTRAP_COMMAND.slice(1), '--defaults', '--name', name, '--cwd', cwd];
+}

package/dist/registry/commands.d.ts

@@ -0,0 +1,2 @@
+export declare function runRegistry(args: string[], json: boolean): Promise<void>;
+export declare function runAdd(args: string[]): Promise<void>;

package/dist/registry/commands.js

@@ -0,0 +1,48 @@
+import path from 'node:path';
+import { addStackItems } from './add.js';
+import { STACK_REGISTRY, getStackItem } from '../stack-registry.js';
+export async function runRegistry(args, json) {
+    const positional = args.filter((arg) => arg !== '--json');
+    if (positional.includes('--help') || positional.includes('-h')) {
+        console.log('anhedral registry list|view [item] [--json]');
+        return;
+    }
+    if (positional.some((arg) => arg.startsWith('-')))
+        throw new Error('Unknown registry option.');
+    const [action = 'list', name, ...extra] = positional;
+    if (action === 'list' && !name && !extra.length) {
+        console.log(json
+            ? JSON.stringify(STACK_REGISTRY, null, 2)
+            : STACK_REGISTRY.items
+                .map((item) => `${item.name} (${item.type}) — ${item.description}`)
+                .join('\n'));
+        return;
+    }
+    if (action === 'view' && name && !extra.length) {
+        console.log(JSON.stringify(getStackItem(name), null, 2));
+        return;
+    }
+    throw new Error('Use registry list or registry view <item>.');
+}
+export async function runAdd(args) {
+    if (args.includes('--help') || args.includes('-h')) {
+        console.log('anhedral add <directory> <items...> [--dry-run] [--skip-install] [--json]');
+        return;
+    }
+    const positional = [];
+    for (const arg of args) {
+        if (['--dry-run', '--skip-install', '--json'].includes(arg))
+            continue;
+        if (arg.startsWith('-'))
+            throw new Error(`Unknown add option: ${arg}.`);
+        positional.push(arg);
+    }
+    const [directory, ...items] = positional;
+    if (!directory || !items.length)
+        throw new Error('Use add <directory> <items...>.');
+    console.log(JSON.stringify(await addStackItems(path.resolve(directory), {
+        items,
+        dryRun: args.includes('--dry-run'),
+        skipInstall: args.includes('--skip-install'),
+    }), null, 2));
+}

package/dist/registry/context.d.ts

@@ -0,0 +1,3 @@
+import type { RecipeContext, StandardOptions } from './types.js';
+export declare function createRecipeContext(root: string, options: StandardOptions): RecipeContext;
+export declare function createResolutionContext(selection: Pick<StandardOptions, 'products' | 'hosting'> & Partial<Pick<StandardOptions, 'name'>>): RecipeContext;

package/dist/registry/context.js

@@ -0,0 +1,21 @@
+export function createRecipeContext(root, options) {
+    const selected = new Set(options.products);
+    return {
+        root,
+        options,
+        has: (product) => selected.has(product),
+        runtimeApp: selected.has('hono') ? 'api' : 'web',
+        bindings: {},
+    };
+}
+export function createResolutionContext(selection) {
+    return createRecipeContext('', {
+        root: '',
+        name: selection.name ?? 'app',
+        skipInstall: true,
+        dryRun: true,
+        json: false,
+        initializeGit: false,
+        ...selection,
+    });
+}

package/dist/registry/options.d.ts

@@ -0,0 +1,2 @@
+import type { StandardOptions } from './types.js';
+export declare function parseStandardOptions(command: 'new' | 'init', args: readonly string[]): StandardOptions;

package/dist/registry/options.js

@@ -0,0 +1,65 @@
+import { resolveStandardProducts } from './resolve.js';
+import path from 'node:path';
+import { packageNameFromText } from '../render.js';
+import { STANDARD_PRODUCTS } from '../stack-registry.js';
+function readGitFlag(token, previous) {
+    const value = token === '--git';
+    if (previous !== undefined && value !== previous)
+        throw new Error('Conflicting Git options.');
+    return value;
+}
+function readHostingFlag(value, previous, specified) {
+    if (value !== 'cloudflare' && value !== 'vercel')
+        throw new Error('hosting must be cloudflare or vercel.');
+    if (specified && previous !== value)
+        throw new Error('Conflicting hosting options.');
+    return value;
+}
+function parseStandardFlags(remaining) {
+    const products = new Set();
+    let hosting = 'cloudflare';
+    let hostingSpecified = false;
+    let gitSpecified;
+    for (let index = 0; index < remaining.length; index++) {
+        const token = remaining[index];
+        if (['--skip-install', '--dry-run', '--json', '--verbose'].includes(token))
+            continue;
+        if (token === '--git' || token === '--no-git') {
+            gitSpecified = readGitFlag(token, gitSpecified);
+            continue;
+        }
+        if (token === '--hosting' || token.startsWith('--hosting=')) {
+            const value = token === '--hosting' ? remaining[++index] : token.slice('--hosting='.length);
+            hosting = readHostingFlag(value, hosting, hostingSpecified);
+            hostingSpecified = true;
+            continue;
+        }
+        const value = token.replace(/^--/, '');
+        if (!STANDARD_PRODUCTS.includes(value)) {
+            throw new Error(`Unknown standard product: ${token}. Select only required products.`);
+        }
+        products.add(value);
+    }
+    if (!hostingSpecified && products.has('next'))
+        hosting = 'vercel';
+    return { products, hosting, hostingSpecified, gitSpecified };
+}
+export function parseStandardOptions(command, args) {
+    const remaining = [...args];
+    const directory = command === 'new' ? remaining.shift() : process.cwd();
+    if (!directory || directory.startsWith('-'))
+        throw new Error('new requires a destination directory.');
+    const root = path.resolve(directory);
+    const { products, hosting, hostingSpecified, gitSpecified } = parseStandardFlags(remaining);
+    resolveStandardProducts(products, hosting, hostingSpecified);
+    return {
+        root,
+        name: packageNameFromText(path.basename(root)),
+        products: [...products].sort(),
+        hosting,
+        skipInstall: remaining.includes('--skip-install'),
+        dryRun: remaining.includes('--dry-run'),
+        json: remaining.includes('--json'),
+        initializeGit: gitSpecified ?? command === 'new',
+    };
+}

package/dist/registry/receipt.d.ts

@@ -0,0 +1,2 @@
+export declare function sourceFiles(root: string): Map<string, string>;
+export declare function recordScaffoldFiles(root: string): void;

package/dist/registry/receipt.js

@@ -0,0 +1,52 @@
+import { createHash } from 'node:crypto';
+import { readFileSync, readdirSync } from 'node:fs';
+import path from 'node:path';
+import { json, readJson } from '../scaffold/files.js';
+const excluded = new Set([
+    '.pnpm-store',
+    '.artifacts',
+    '.git',
+    'node_modules',
+    '.next',
+    '.open-next',
+    '.wrangler',
+    '.turbo',
+    'dist',
+    '.output',
+    '.expo',
+    '.fallow',
+    '.anhedral',
+    '.anhedral.lock',
+    '.anhedral-txn',
+    'anhedral.registry.json',
+]);
+export function sourceFiles(root) {
+    const files = new Map();
+    const visit = (directory) => {
+        for (const entry of readdirSync(path.join(root, directory), { withFileTypes: true })) {
+            if (excluded.has(entry.name))
+                continue;
+            const relative = directory ? `${directory}/${entry.name}` : entry.name;
+            // Local credentials are never seeded into an addition transaction or fingerprint receipt.
+            if (/^(?:\.env|\.dev\.vars)(?:\.|$)/.test(entry.name) && !entry.name.endsWith('.example'))
+                continue;
+            if (entry.isSymbolicLink())
+                throw new Error(`Source symlinks are unsupported: ${relative}.`);
+            if (entry.isDirectory())
+                visit(relative);
+            else if (entry.isFile())
+                files.set(relative, createHash('sha256')
+                    .update(readFileSync(path.join(root, relative)))
+                    .digest('hex'));
+        }
+    };
+    visit('');
+    return files;
+}
+export function recordScaffoldFiles(root) {
+    const receipt = readJson(root, 'anhedral.registry.json');
+    json(root, 'anhedral.registry.json', {
+        ...receipt,
+        files: Object.fromEntries(sourceFiles(root)),
+    });
+}

package/dist/registry/resolve.d.ts

@@ -0,0 +1,10 @@
+import type { Hosting, StandardOptions, StandardProduct, StackRegistryItem } from './types.js';
+/** Apply default selections once. All callers then use the same strict graph resolver. */
+export declare function resolveStandardProducts(selected: Set<StandardProduct>, hosting: Hosting, hostingSpecified: boolean): void;
+export interface ResolvedStackRegistry {
+    schemaVersion: number;
+    name: string;
+    cliVersion: string;
+    items: StackRegistryItem[];
+}
+export declare function resolveStackRegistry(options: Pick<StandardOptions, 'products' | 'hosting'> & Partial<Pick<StandardOptions, 'name'>>): ResolvedStackRegistry;

package/dist/registry/resolve.js

@@ -0,0 +1,98 @@
+import { dependencyOrder } from '../dependency-order.js';
+import { STANDARD_PRODUCTS, STACK_REGISTRY, getStackDefinition, getStackItem, } from '../stack-registry.js';
+import { createResolutionContext } from './context.js';
+function hasServer(context) {
+    return context.has('hono') || context.has('vinext') || context.has('next');
+}
+function needsWorker(name, context) {
+    const definition = getStackDefinition(name);
+    return (definition.runtime === 'worker' ||
+        (definition.runtime === 'optional-worker' && hasServer(context)));
+}
+function validateProducts(selected, hosting) {
+    if (!['cloudflare', 'vercel'].includes(hosting))
+        throw new Error('hosting must be cloudflare or vercel.');
+    for (const id of selected) {
+        if (!STANDARD_PRODUCTS.includes(id))
+            throw new Error(`Unknown stack product: ${id}.`);
+        const { conflicts = [], requiresAny = [], requiresAll = [] } = getStackDefinition(id).selection;
+        const conflict = conflicts.find((other) => selected.has(other));
+        if (conflict)
+            throw new Error(`Choose one of ${id} / ${conflict}.`);
+        if (requiresAny.length && !requiresAny.some((other) => selected.has(other)))
+            throw new Error(`${id} requires an explicitly selected ${requiresAny.join(' or ')} capability.`);
+        const missing = requiresAll.filter((other) => !selected.has(other));
+        if (missing.length)
+            throw new Error(`${id} requires ${missing.join(', ')}; select it explicitly.`);
+    }
+    if (selected.has('vinext') && hosting !== 'cloudflare')
+        throw new Error('Vinext requires Cloudflare hosting; select --next for Vercel.');
+}
+/** Apply default selections once. All callers then use the same strict graph resolver. */
+export function resolveStandardProducts(selected, hosting, hostingSpecified) {
+    for (const id of selected)
+        getStackDefinition(id);
+    if (![...selected].some((id) => getStackDefinition(id).type === 'application'))
+        selected.add(hosting === 'vercel' ? 'next' : 'vinext');
+    for (const id of selected) {
+        const definition = getStackDefinition(id);
+        const alternatives = definition.selection.requiresAny ?? [];
+        if (definition.fallbackDependency &&
+            !alternatives.some((other) => selected.has(other)))
+            selected.add(definition.fallbackDependency);
+    }
+    const context = createResolutionContext({ products: [...selected], hosting });
+    if (context.has('next') &&
+        hosting === 'vercel' &&
+        [...selected].some((id) => needsWorker(id, context)))
+        selected.add('hono');
+    if (hostingSpecified && !selected.has('next') && !selected.has('vinext'))
+        throw new Error('--hosting applies to the web application.');
+    resolveStackRegistry({ products: [...selected], hosting });
+}
+export function resolveStackRegistry(options) {
+    const selected = new Set(options.products);
+    validateProducts(selected, options.hosting);
+    if (![...selected].some((id) => getStackDefinition(id).type === 'application'))
+        throw new Error('Stack registry requires an application.');
+    const context = createResolutionContext(options);
+    const resolved = new Map();
+    const collect = (name) => {
+        if (resolved.has(name))
+            return;
+        const definition = getStackDefinition(name);
+        const metadata = getStackItem(name);
+        const dependencies = new Set(definition.registryDependencies);
+        if (definition.runtime) {
+            if (!hasServer(context) && definition.runtime !== 'optional-worker')
+                throw new Error(`${name} requires a server runtime.`);
+            if (needsWorker(name, context) &&
+                !context.has('hono') &&
+                !(options.hosting === 'cloudflare' && (context.has('vinext') || context.has('next'))))
+                throw new Error(`${name} requires a Cloudflare runtime.`);
+            if (hasServer(context))
+                dependencies.add(context.has('hono') ? 'hono' : context.has('vinext') ? 'vinext' : 'next');
+        }
+        for (const dependency of definition.resolveDependencies?.(context) ?? [])
+            dependencies.add(dependency);
+        metadata.registryDependencies = [...dependencies];
+        metadata.targets = definition.resolveTargets?.(context) ?? metadata.targets;
+        if (definition.configure)
+            metadata.bindings = definition.configure(context);
+        if (definition.package)
+            metadata.package =
+                definition.resolvePackage?.(context, definition.package) ?? definition.package;
+        resolved.set(name, metadata);
+        for (const dependency of dependencies)
+            collect(dependency);
+    };
+    for (const name of ['workspace', 'typescript', 'eslint', ...[...selected].sort()])
+        collect(name);
+    const graph = new Map([...resolved].map(([name, item]) => [name, item.registryDependencies]));
+    return {
+        schemaVersion: STACK_REGISTRY.schemaVersion,
+        name: STACK_REGISTRY.name,
+        cliVersion: STACK_REGISTRY.cliVersion,
+        items: dependencyOrder(graph, 'Stack registry').map((name) => resolved.get(name)),
+    };
+}

package/dist/registry/types.d.ts

@@ -0,0 +1,64 @@
+import type { StandardProduct } from '../stack-registry.js';
+import type { Json } from '../scaffold/files.js';
+export type { StandardProduct } from '../stack-registry.js';
+export type Hosting = 'cloudflare' | 'vercel';
+export interface StandardOptions {
+    root: string;
+    name: string;
+    products: StandardProduct[];
+    hosting: Hosting;
+    skipInstall: boolean;
+    dryRun: boolean;
+    json: boolean;
+    initializeGit: boolean;
+}
+export type StandardRunner = (command: string, args: string[], cwd: string) => void;
+export interface StackSelection {
+    conflicts?: readonly string[];
+    requiresAny?: readonly string[];
+    requiresAll?: readonly string[];
+}
+export interface SetupRequirements {
+    purpose: string;
+    tools: readonly string[];
+    access: readonly string[];
+    credentials: readonly string[];
+    resources: readonly string[];
+    verify: readonly string[];
+}
+export interface RecipeContext {
+    root: string;
+    options: StandardOptions;
+    runtimeApp: 'api' | 'web';
+    bindings: Json;
+    has: (product: string) => boolean;
+}
+export type Recipe = (context: RecipeContext) => void | Promise<void>;
+export interface PackageRecipe {
+    name: string;
+    source: string;
+    dependencies: Record<string, string>;
+}
+export interface StackRegistryItem {
+    name: string;
+    version: string;
+    type: 'foundation' | 'application' | 'service' | 'package' | 'integration';
+    description: string;
+    registryDependencies: readonly string[];
+    targets: readonly string[];
+    selection: StackSelection;
+    installer: 'bootstrap' | 'recipe' | 'configuration';
+    runtime?: 'server' | 'worker' | 'optional-worker';
+    environment: readonly string[];
+    setup?: SetupRequirements;
+    package?: PackageRecipe;
+    bindings?: Json;
+}
+export interface ItemDefinition extends Omit<StackRegistryItem, 'bindings'> {
+    install?: Recipe;
+    configure?: (context: RecipeContext) => Json;
+    resolveTargets?: (context: RecipeContext) => string[];
+    resolvePackage?: (context: RecipeContext, recipe: PackageRecipe) => PackageRecipe;
+    resolveDependencies?: (context: RecipeContext) => string[];
+    fallbackDependency?: string;
+}

package/dist/registry/usage.d.ts

@@ -0,0 +1 @@
+export declare const STANDARD_USAGE: string;

package/dist/registry/usage.js

@@ -0,0 +1,37 @@
+import { STANDARD_PRODUCTS } from '../stack-registry.js';
+export const STANDARD_USAGE = `Anhedral Application Stack & Delivery Standard
+
+anhedral new <directory> [products...] [--hosting cloudflare|vercel] [--skip-install] [--no-git] [--dry-run] [--json]
+anhedral add <directory> <items...> [--dry-run] [--skip-install] [--json]
+anhedral init [products...] [--hosting cloudflare|vercel] [--skip-install] [--git] [--dry-run] [--json]
+
+Default: Vinext on Cloudflare Workers, from the official shadcn pnpm/Turborepo monorepo.
+Web hosting: Vinext on Cloudflare by default; native Next.js on Vercel is an explicit option.
+Products: ${STANDARD_PRODUCTS.join(', ')}
+Examples:
+  anhedral new client-app
+  anhedral new mobile-app --expo
+  anhedral new product --next --expo --hono --neon --clerk --r2
+  anhedral new website --next --stripe --resend
+  anhedral init --wxt
+  anhedral cloud register|stage|save|deploy|status [directory] (managed service API required)
+  anhedral registry list|view [item] [--json]
+  anhedral doctor [directory] [--providers] --json
+  anhedral repository [directory] [--owner <github-account>] [--name <repo>] [--visibility private|public] [--create]
+  anhedral register [directory]
+  anhedral connect [directory] [--scope <team>] --audience public|private --use personal|commercial [--create] [--git]
+  anhedral connect [directory] --provider cloudflare [--account <id>] --audience public|private [--allow-email <email>]
+  anhedral provision [directory] [--dry-run] [--json]
+  anhedral ship [directory] [--dry-run] [--json]
+  anhedral adopt [directory] --provider vercel [--json]
+  anhedral recover [directory] [--provider vercel|cloudflare] [--json]
+  anhedral status [directory] [--refresh] [--json]
+  anhedral manage [directory] [--local] [--json]
+  anhedral verify [directory] [--json]
+  anhedral rollback [directory] --release <id> --data-compatible [--json]
+
+--skip-install skips the final workspace install; the official shadcn bootstrap
+still requires network access and may install its own dependencies.
+--all is intentionally unsupported: select only required capabilities.
+Vercel Hobby is personal/non-commercial with limits; commercial apps need a suitable existing plan.
+`;

package/dist/render.d.ts

@@ -8,7 +8,3 @@ export declare function markdownHeading(value: string): string;
 export declare function packageNameFromText(value: string): string;
 export declare function childPackageName(projectName: string, suffix: string): string;
 export declare function identifierSegment(value: string): string;
-/** Project names also become bootstrap directory components; scoped names are not supported. */
-export declare function assertProjectName(value: string): string;
-/** Provider identifiers obey DNS/R2 limits independently of valid npm names. */
-export declare function resourceName(projectName: string, suffix: string): string;

package/dist/render.js

@@ -22,9 +22,9 @@ export function markdownHeading(value) {
 }
 function assertPackageName(value) {
     const leafName = value.slice(value.lastIndexOf('/') + 1);
-    if (value.length > MAX_PACKAGE_NAME_LENGTH
-        || !PACKAGE_NAME_PATTERN.test(value)
-        || RESERVED_PACKAGE_NAMES.has(leafName)) {
+    if (value.length > MAX_PACKAGE_NAME_LENGTH ||
+        !PACKAGE_NAME_PATTERN.test(value) ||
+        RESERVED_PACKAGE_NAMES.has(leafName)) {
         throw new Error(`Invalid package name: ${value}`);
     }
     return value;
@@ -72,16 +72,3 @@ export function identifierSegment(value) {
         .replace(/^-+|-+$/g, '');
     return segment || 'app';
 }
-/** Project names also become bootstrap directory components; scoped names are not supported. */
-export function assertProjectName(value) {
-    if (typeof value !== 'string' || value.includes('/'))
-        throw new Error('Project name must be a valid unscoped npm package name.');
-    return assertPackageName(value);
-}
-/** Provider identifiers obey DNS/R2 limits independently of valid npm names. */
-export function resourceName(projectName, suffix) {
-    const normalized = identifierSegment(projectName);
-    const digest = createHash('sha256').update(projectName, 'utf8').digest('hex').slice(0, 8);
-    const distinct = normalized === projectName ? normalized : `${normalized}-${digest}`;
-    return `${compactPackageSegment(distinct, 63 - suffix.length - 1)}-${suffix}`;
-}