anhedral 0.4.1 → 0.6.0

package/dist/architecture/modules.js

@@ -1,184 +0,0 @@
-export const MODULE_IDS = [
-    'web',
-    'mobile',
-    'api',
-    'desktop',
-    'extension',
-    'db',
-    'auth',
-    'billing',
-    'storage',
-    'native-subscriptions',
-    'electron-updater',
-];
-export class ModuleRegistryError extends Error {
-    code;
-    modules;
-    constructor(code, message, modules = []) {
-        super(message);
-        this.code = code;
-        this.modules = modules;
-        this.name = 'ModuleRegistryError';
-    }
-}
-export class ModuleResolutionError extends Error {
-    code;
-    modules;
-    constructor(code, message, modules) {
-        super(message);
-        this.code = code;
-        this.modules = modules;
-        this.name = 'ModuleResolutionError';
-    }
-}
-const MODULE_ID_SET = new Set(MODULE_IDS);
-const MODULE_ORDER = new Map(MODULE_IDS.map((id, index) => [id, index]));
-export function isModuleId(value) {
-    return typeof value === 'string' && MODULE_ID_SET.has(value);
-}
-function compareModules(left, right) {
-    return (MODULE_ORDER.get(left) ?? Number.MAX_SAFE_INTEGER)
-        - (MODULE_ORDER.get(right) ?? Number.MAX_SAFE_INTEGER);
-}
-function normalizeModuleList(values) {
-    return Object.freeze([...new Set(values)].sort(compareModules));
-}
-function freezeDefinition(definition) {
-    return Object.freeze({
-        id: definition.id,
-        kind: definition.kind,
-        requires: normalizeModuleList(definition.requires),
-        conflicts: normalizeModuleList(definition.conflicts),
-    });
-}
-function assertNoDependencyCycles(registry) {
-    const visited = new Set();
-    const active = new Set();
-    const stack = [];
-    const visit = (moduleId) => {
-        if (visited.has(moduleId))
-            return;
-        if (active.has(moduleId)) {
-            const cycleStart = stack.indexOf(moduleId);
-            const cycle = [...stack.slice(cycleStart), moduleId];
-            throw new ModuleRegistryError('DEPENDENCY_CYCLE', `Module dependency cycle detected: ${cycle.join(' -> ')}`, Object.freeze(cycle));
-        }
-        active.add(moduleId);
-        stack.push(moduleId);
-        for (const required of registry[moduleId].requires)
-            visit(required);
-        stack.pop();
-        active.delete(moduleId);
-        visited.add(moduleId);
-    };
-    for (const moduleId of MODULE_IDS)
-        visit(moduleId);
-}
-export function createModuleRegistry(definitions) {
-    const registry = {};
-    for (const definition of definitions) {
-        if (!isModuleId(definition.id)) {
-            throw new ModuleRegistryError('UNKNOWN_MODULE_REFERENCE', `Unknown module definition: ${String(definition.id)}`, Object.freeze([String(definition.id)]));
-        }
-        if (registry[definition.id]) {
-            throw new ModuleRegistryError('DUPLICATE_MODULE_DEFINITION', `Duplicate module definition: ${definition.id}`, Object.freeze([definition.id]));
-        }
-        for (const required of definition.requires) {
-            if (!isModuleId(required)) {
-                throw new ModuleRegistryError('UNKNOWN_MODULE_REFERENCE', `Module ${definition.id} requires unknown module ${String(required)}`, Object.freeze([definition.id, String(required)]));
-            }
-            if (required === definition.id) {
-                throw new ModuleRegistryError('SELF_DEPENDENCY', `Module ${definition.id} cannot require itself`, Object.freeze([definition.id]));
-            }
-        }
-        for (const conflict of definition.conflicts) {
-            if (!isModuleId(conflict)) {
-                throw new ModuleRegistryError('UNKNOWN_MODULE_REFERENCE', `Module ${definition.id} conflicts with unknown module ${String(conflict)}`, Object.freeze([definition.id, String(conflict)]));
-            }
-            if (conflict === definition.id) {
-                throw new ModuleRegistryError('SELF_CONFLICT', `Module ${definition.id} cannot conflict with itself`, Object.freeze([definition.id]));
-            }
-        }
-        registry[definition.id] = freezeDefinition(definition);
-    }
-    const missing = MODULE_IDS.filter((moduleId) => !registry[moduleId]);
-    if (missing.length > 0) {
-        throw new ModuleRegistryError('MISSING_MODULE_DEFINITION', `Missing module definitions: ${missing.join(', ')}`, Object.freeze(missing));
-    }
-    const completeRegistry = Object.freeze(registry);
-    assertNoDependencyCycles(completeRegistry);
-    return completeRegistry;
-}
-const DEFAULT_MODULE_DEFINITION_INPUTS = [
-    { id: 'web', kind: 'app', requires: [], conflicts: [] },
-    { id: 'mobile', kind: 'app', requires: [], conflicts: [] },
-    { id: 'api', kind: 'app', requires: [], conflicts: [] },
-    { id: 'desktop', kind: 'app', requires: [], conflicts: [] },
-    { id: 'extension', kind: 'app', requires: [], conflicts: [] },
-    { id: 'db', kind: 'feature', requires: [], conflicts: [] },
-    { id: 'auth', kind: 'feature', requires: ['api', 'db'], conflicts: [] },
-    { id: 'billing', kind: 'feature', requires: ['auth'], conflicts: [] },
-    { id: 'storage', kind: 'feature', requires: ['auth'], conflicts: [] },
-    { id: 'native-subscriptions', kind: 'feature', requires: ['mobile', 'billing'], conflicts: [] },
-    { id: 'electron-updater', kind: 'feature', requires: ['desktop'], conflicts: [] },
-];
-export const DEFAULT_MODULE_DEFINITIONS = Object.freeze(DEFAULT_MODULE_DEFINITION_INPUTS.map(freezeDefinition));
-export const DEFAULT_MODULE_REGISTRY = createModuleRegistry(DEFAULT_MODULE_DEFINITIONS);
-export function resolveModules(requested, registry = DEFAULT_MODULE_REGISTRY) {
-    const unknown = [...new Set(requested.filter((moduleId) => !isModuleId(moduleId)))].sort();
-    if (unknown.length > 0) {
-        throw new ModuleResolutionError('UNKNOWN_MODULE', `Unknown modules: ${unknown.join(', ')}`, Object.freeze(unknown));
-    }
-    const requestedModules = normalizeModuleList(requested);
-    const resolved = new Set();
-    const visiting = new Set();
-    const ordered = [];
-    const visit = (moduleId) => {
-        if (resolved.has(moduleId))
-            return;
-        if (visiting.has(moduleId)) {
-            throw new ModuleRegistryError('DEPENDENCY_CYCLE', `Module dependency cycle reached while resolving ${moduleId}`, Object.freeze([moduleId]));
-        }
-        visiting.add(moduleId);
-        for (const required of registry[moduleId].requires)
-            visit(required);
-        visiting.delete(moduleId);
-        resolved.add(moduleId);
-        ordered.push(moduleId);
-    };
-    for (const moduleId of requestedModules)
-        visit(moduleId);
-    const conflictPairs = new Set();
-    for (const moduleId of ordered) {
-        for (const conflict of registry[moduleId].conflicts) {
-            if (!resolved.has(conflict))
-                continue;
-            const pair = [moduleId, conflict].sort(compareModules);
-            conflictPairs.add(`${pair[0]}\0${pair[1]}`);
-        }
-    }
-    if (conflictPairs.size > 0) {
-        const conflicts = [...conflictPairs]
-            .map((pair) => pair.split('\0'))
-            .sort(([leftA, leftB], [rightA, rightB]) => compareModules(leftA, rightA) || compareModules(leftB, rightB));
-        const modules = Object.freeze([...new Set(conflicts.flat())].sort(compareModules));
-        throw new ModuleResolutionError('MODULE_CONFLICT', `Conflicting modules: ${conflicts.map(([left, right]) => `${left} + ${right}`).join(', ')}`, modules);
-    }
-    // Resolution must have one stable representation regardless of whether a
-    // dependency was requested directly or discovered while walking another
-    // module. Without this final normalization, adding a module to an existing
-    // project could produce a different manifest order than creating the same
-    // topology directly (for example, adding electron-updater after db/auth).
-    const resolvedModules = normalizeModuleList(ordered);
-    const requestedSet = new Set(requestedModules);
-    const dependencyAddedModules = resolvedModules.filter((moduleId) => !requestedSet.has(moduleId));
-    const dependencyEdges = resolvedModules.flatMap((moduleId) => registry[moduleId].requires
-        .filter((required) => resolved.has(required))
-        .map((required) => Object.freeze({ module: moduleId, requires: required })));
-    return Object.freeze({
-        requestedModules,
-        resolvedModules,
-        dependencyAddedModules: Object.freeze(dependencyAddedModules),
-        dependencyEdges: Object.freeze(dependencyEdges),
-    });
-}

package/dist/architecture/plan.d.ts

@@ -1,58 +0,0 @@
-import { type DependencyEdge, type ModuleId, type ModuleRegistry } from './modules.js';
-export declare const FILE_OWNERSHIP_CLASSES: readonly ["managed", "mergeable", "user"];
-export type FileOwnershipClass = (typeof FILE_OWNERSHIP_CLASSES)[number];
-export type FileOwner = ModuleId | 'root';
-export type GenerationOperation = 'init' | 'add';
-export type FileWritePolicy = 'replace-if-unmodified' | 'structural-merge' | 'create-only';
-export type PlanFileInput = {
-    readonly path: string;
-    readonly ownership: FileOwnershipClass;
-    readonly content: string;
-};
-export type ModulePlanContribution = {
-    readonly module: FileOwner;
-    readonly files: readonly PlanFileInput[];
-};
-export type PlannedFile = {
-    readonly path: string;
-    readonly owner: FileOwner;
-    readonly ownership: FileOwnershipClass;
-    readonly writePolicy: FileWritePolicy;
-    readonly content: string;
-    readonly contentHash: string;
-};
-export type GenerationPlan = {
-    readonly planVersion: 1;
-    readonly operation: GenerationOperation;
-    readonly requestedModules: readonly ModuleId[];
-    readonly resolvedModules: readonly ModuleId[];
-    readonly dependencyAddedModules: readonly ModuleId[];
-    readonly dependencyEdges: readonly DependencyEdge[];
-    readonly files: readonly PlannedFile[];
-    readonly fingerprint: string;
-};
-export type BuildGenerationPlanInput = {
-    readonly operation: GenerationOperation;
-    readonly requestedModules: readonly string[];
-    readonly contributions?: readonly ModulePlanContribution[];
-    readonly registry?: ModuleRegistry;
-};
-export type PlanBuildErrorCode = 'INVALID_OPERATION' | 'INVALID_PLAN_PATH' | 'INVALID_FILE_OWNER' | 'INVALID_FILE_OWNERSHIP' | 'INVALID_FILE_CONTENT' | 'UNRESOLVED_CONTRIBUTION' | 'DUPLICATE_OUTPUT_PATH';
-export declare class PlanBuildError extends Error {
-    readonly code: PlanBuildErrorCode;
-    readonly paths: readonly string[];
-    constructor(code: PlanBuildErrorCode, message: string, paths?: readonly string[]);
-}
-export declare function isFileOwnershipClass(value: unknown): value is FileOwnershipClass;
-export declare function isSha256(value: unknown): value is string;
-/**
- * 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 declare function hashContent(content: string | Uint8Array): string;
-export declare function writePolicyForOwnership(ownership: FileOwnershipClass): FileWritePolicy;
-export declare function normalizePlanPath(value: string): string;
-export declare function buildGenerationPlan(input: BuildGenerationPlanInput): GenerationPlan;

package/dist/architecture/plan.js

@@ -1,145 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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/cli.d.ts

@@ -1,32 +0,0 @@
-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;