anhedral 0.1.10 → 0.3.0

package/dist/ui.d.ts

@@ -0,0 +1,33 @@
+export declare const UI_TARGETS: readonly ["web", "mobile", "desktop", "extension"];
+export declare const NATIVE_STYLING_LIBRARIES: readonly ["nativewind", "uniwind"];
+export declare const UI_PROVIDERS: readonly ["shadcn", "react-native-reusables"];
+export type UiTarget = (typeof UI_TARGETS)[number];
+export type NativeStylingLibrary = (typeof NATIVE_STYLING_LIBRARIES)[number];
+export type UiProvider = (typeof UI_PROVIDERS)[number];
+export type UiComponentInstall = {
+    readonly name: string;
+    readonly target: UiTarget;
+    readonly provider: UiProvider;
+    readonly source: string;
+    readonly variant: NativeStylingLibrary | null;
+};
+export type UiInstallCommand = {
+    readonly target: UiTarget;
+    readonly cwd: string;
+    readonly executable: 'pnpm';
+    readonly args: readonly string[];
+    readonly installs: readonly UiComponentInstall[];
+};
+export declare function reconcileUiWorkspaceDependencies(workspaceRoot: string, targetDirectory: string): void;
+export declare function isUiTarget(value: unknown): value is UiTarget;
+export declare function isNativeStylingLibrary(value: unknown): value is NativeStylingLibrary;
+export declare function isUiProvider(value: unknown): value is UiProvider;
+export declare function normalizeUiComponentName(value: string): string;
+export declare function parseUiComponentList(value: string): string[];
+export declare function providerForTarget(target: UiTarget): UiProvider;
+export declare function registrySourceFor(name: string, target: UiTarget, nativeStyling: NativeStylingLibrary): string;
+export declare function resolveUiInstalls(componentNames: readonly string[], targets: readonly UiTarget[], nativeStyling: NativeStylingLibrary): readonly UiComponentInstall[];
+export declare function uiInstallKey(install: Pick<UiComponentInstall, 'target' | 'name'>): string;
+export declare function mergeUiInstalls(current: readonly UiComponentInstall[], additions: readonly UiComponentInstall[]): readonly UiComponentInstall[];
+export declare function buildUiInstallCommands(root: string, installs: readonly UiComponentInstall[]): readonly UiInstallCommand[];
+export declare function installUiComponents(root: string, installs: readonly UiComponentInstall[]): void;

package/dist/ui.js

@@ -0,0 +1,199 @@
+import path from 'node:path';
+import { existsSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { TOOLCHAIN_DEPENDENCIES } from './dependencies.js';
+import { execFile } from './util.js';
+export const UI_TARGETS = ['web', 'mobile', 'desktop', 'extension'];
+export const NATIVE_STYLING_LIBRARIES = ['nativewind', 'uniwind'];
+export const UI_PROVIDERS = ['shadcn', 'react-native-reusables'];
+const COMPONENT_NAME_PATTERN = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
+const SOURCE_EXTENSION_PATTERN = /\.(?:[cm]?[jt]sx?)$/;
+const IMPORT_SPECIFIER_PATTERN = /(?:\bfrom\s*|\bimport\s*\(\s*|\brequire\s*\(\s*)['"]([^'"]+)['"]/g;
+function collectSourcePackageImports(root) {
+    const packages = new Set();
+    const visit = (directory) => {
+        for (const entry of readdirSync(directory, { withFileTypes: true })) {
+            if (entry.name === 'node_modules' || entry.name === '.git' || entry.name.startsWith('.next'))
+                continue;
+            const absolutePath = path.join(directory, entry.name);
+            if (entry.isDirectory()) {
+                visit(absolutePath);
+                continue;
+            }
+            if (!entry.isFile() || !SOURCE_EXTENSION_PATTERN.test(entry.name))
+                continue;
+            const source = readFileSync(absolutePath, 'utf8');
+            for (const match of source.matchAll(IMPORT_SPECIFIER_PATTERN)) {
+                const specifier = match[1];
+                if (specifier.startsWith('.') || specifier.startsWith('/') || specifier.startsWith('#')
+                    || specifier.startsWith('@/') || specifier.startsWith('node:') || specifier.startsWith('virtual:'))
+                    continue;
+                const segments = specifier.split('/');
+                packages.add(specifier.startsWith('@') ? segments.slice(0, 2).join('/') : segments[0]);
+            }
+        }
+    };
+    visit(root);
+    return packages;
+}
+function workspacePackageManifests(workspaceRoot) {
+    const manifests = [];
+    for (const directory of [workspaceRoot, path.join(workspaceRoot, 'apps'), path.join(workspaceRoot, 'packages')]) {
+        if (!existsSync(directory))
+            continue;
+        for (const entry of readdirSync(directory, { withFileTypes: true })) {
+            const packagePath = entry.isDirectory()
+                ? path.join(directory, entry.name, 'package.json')
+                : entry.name === 'package.json' ? path.join(directory, entry.name) : '';
+            if (!packagePath)
+                continue;
+            try {
+                manifests.push(JSON.parse(readFileSync(packagePath, 'utf8')));
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+        }
+    }
+    return manifests;
+}
+export function reconcileUiWorkspaceDependencies(workspaceRoot, targetDirectory) {
+    const packagePath = path.join(targetDirectory, 'package.json');
+    const target = JSON.parse(readFileSync(packagePath, 'utf8'));
+    const declared = new Set([
+        ...Object.keys(target.dependencies ?? {}),
+        ...Object.keys(target.devDependencies ?? {}),
+        ...Object.keys(target.optionalDependencies ?? {}),
+        ...Object.keys(target.peerDependencies ?? {}),
+    ]);
+    const manifests = workspacePackageManifests(workspaceRoot);
+    const dependencies = { ...(target.dependencies ?? {}) };
+    let changed = false;
+    for (const packageName of collectSourcePackageImports(targetDirectory)) {
+        if (declared.has(packageName))
+            continue;
+        const version = manifests
+            .map((manifest) => manifest.dependencies?.[packageName])
+            .find((candidate) => typeof candidate === 'string');
+        if (!version)
+            continue;
+        dependencies[packageName] = version;
+        declared.add(packageName);
+        changed = true;
+    }
+    if (!changed)
+        return;
+    target.dependencies = Object.fromEntries(Object.entries(dependencies).sort(([left], [right]) => left.localeCompare(right)));
+    writeFileSync(packagePath, JSON.stringify(target, null, 2) + '\n');
+}
+export function isUiTarget(value) {
+    return typeof value === 'string' && UI_TARGETS.includes(value);
+}
+export function isNativeStylingLibrary(value) {
+    return typeof value === 'string' && NATIVE_STYLING_LIBRARIES.includes(value);
+}
+export function isUiProvider(value) {
+    return typeof value === 'string' && UI_PROVIDERS.includes(value);
+}
+export function normalizeUiComponentName(value) {
+    const normalized = value.trim().toLowerCase();
+    if (!COMPONENT_NAME_PATTERN.test(normalized)) {
+        throw new Error(`Invalid UI component name: ${value}. Use lowercase letters, numbers, and hyphens.`);
+    }
+    return normalized;
+}
+export function parseUiComponentList(value) {
+    return Array.from(new Set(value
+        .split(/[\s,]+/)
+        .map((entry) => entry.trim())
+        .filter(Boolean)
+        .map(normalizeUiComponentName)));
+}
+export function providerForTarget(target) {
+    return target === 'mobile' ? 'react-native-reusables' : 'shadcn';
+}
+export function registrySourceFor(name, target, nativeStyling) {
+    const component = normalizeUiComponentName(name);
+    return target === 'mobile'
+        ? `https://reactnativereusables.com/r/${nativeStyling}/${component}.json`
+        : component;
+}
+export function resolveUiInstalls(componentNames, targets, nativeStyling) {
+    const components = Array.from(new Set(componentNames.map(normalizeUiComponentName))).sort();
+    const uniqueTargets = Array.from(new Set(targets)).sort();
+    return Object.freeze(uniqueTargets.flatMap((target) => components.map((name) => Object.freeze({
+        name,
+        target,
+        provider: providerForTarget(target),
+        source: registrySourceFor(name, target, nativeStyling),
+        variant: target === 'mobile' ? nativeStyling : null,
+    }))));
+}
+export function uiInstallKey(install) {
+    return `${install.target}:${install.name}`;
+}
+export function mergeUiInstalls(current, additions) {
+    const byKey = new Map(current.map((entry) => [uiInstallKey(entry), entry]));
+    for (const entry of additions)
+        byKey.set(uiInstallKey(entry), entry);
+    return Object.freeze([...byKey.values()].sort((left, right) => uiInstallKey(left).localeCompare(uiInstallKey(right))));
+}
+export function buildUiInstallCommands(root, installs) {
+    const commands = [];
+    for (const target of UI_TARGETS) {
+        const targetInstalls = installs.filter((entry) => entry.target === target);
+        if (targetInstalls.length === 0)
+            continue;
+        commands.push(Object.freeze({
+            target,
+            cwd: path.join(root, 'apps', target),
+            executable: 'pnpm',
+            args: Object.freeze([
+                'dlx',
+                `shadcn@${TOOLCHAIN_DEPENDENCIES.shadcn}`,
+                'add',
+                '--yes',
+                '--overwrite',
+                '--silent',
+                ...targetInstalls.map((entry) => entry.source),
+            ]),
+            installs: Object.freeze(targetInstalls),
+        }));
+    }
+    return Object.freeze(commands);
+}
+export function installUiComponents(root, installs) {
+    for (const command of buildUiInstallCommands(root, installs)) {
+        if (command.target !== 'mobile') {
+            execFile(command.executable, command.args, command.cwd);
+            reconcileUiWorkspaceDependencies(root, command.cwd);
+            continue;
+        }
+        // shadcn switches to `npx expo install` whenever it sees an Expo dependency.
+        // Component generation runs in Anhedral's isolated stage before node_modules
+        // exists, so Expo CLI cannot determine the SDK. Temporarily mask only that
+        // detector field, let shadcn merge registry dependencies with pnpm, then
+        // restore Anhedral's exact Expo pin before the staged diff is committed.
+        const packagePath = path.join(command.cwd, 'package.json');
+        const originalText = readFileSync(packagePath, 'utf8');
+        const original = JSON.parse(originalText);
+        const expoVersion = original.dependencies?.expo;
+        if (!expoVersion)
+            throw new Error(`Expo dependency is missing from ${packagePath}`);
+        const masked = structuredClone(original);
+        delete masked.dependencies?.expo;
+        writeFileSync(packagePath, JSON.stringify(masked, null, 2) + '\n');
+        try {
+            execFile(command.executable, command.args, command.cwd);
+            const updated = JSON.parse(readFileSync(packagePath, 'utf8'));
+            updated.dependencies = { ...(updated.dependencies ?? {}), expo: expoVersion };
+            updated.dependencies = Object.fromEntries(Object.entries(updated.dependencies).sort(([left], [right]) => left.localeCompare(right)));
+            writeFileSync(packagePath, JSON.stringify(updated, null, 2) + '\n');
+            reconcileUiWorkspaceDependencies(root, command.cwd);
+        }
+        catch (error) {
+            writeFileSync(packagePath, originalText);
+            throw error;
+        }
+    }
+}

package/dist/util.d.ts

@@ -1,7 +1,3 @@
 export declare function writeFile(filePath: string, content: string): void;
 export declare function appendGitignore(root: string, lines: string[]): void;
-export declare function exec(cmd: string, cwd: string): void;
-export declare function execCommand(command: string, args: string[], cwd: string): void;
-export declare function execWithInput(cmd: string, cwd: string, stdinInput: string): void;
-export declare function liftNestedProject(root: string, nestedName: string): void;
-export declare function execExpect(cmd: string, cwd: string, prompts: [waitFor: string, answer: string][], timeoutMs?: number): Promise<void>;
+export declare function execFile(executable: string, args: readonly string[], cwd: string): void;

package/dist/util.js

@@ -1,180 +1,91 @@
-import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
-import { execSync, spawn, spawnSync } from 'node:child_process';
+import { chmodSync, closeSync, existsSync, fstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readSync, rmSync, writeFileSync, } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { tmpdir } from 'node:os';
 import path from 'node:path';
+const FAILURE_TAIL_BYTES = 128 * 1024;
 export function writeFile(filePath, content) {
+    const existed = existsSync(filePath);
     mkdirSync(path.dirname(filePath), { recursive: true });
-    writeFileSync(filePath, content, 'utf-8');
+    writeFileSync(filePath, content, { encoding: 'utf8', mode: 0o644 });
+    // Defeat a restrictive caller umask for newly generated files. Existing seeded
+    // files retain their user-selected mode across structural merges.
+    if (!existed)
+        chmodSync(filePath, 0o644);
 }
 export function appendGitignore(root, lines) {
     const filePath = path.join(root, '.gitignore');
-    const existing = existsSync(filePath)
-        ? readFileSync(filePath, 'utf-8').split('\n').map((line) => line.trim()).filter(Boolean)
-        : [];
-    const merged = [...new Set([...existing, ...lines])];
-    writeFile(filePath, merged.join('\n') + '\n');
-}
-const VERBOSE = process.env.ANHEDRAL_VERBOSE === '1';
-function dumpFailure(error, cmd) {
-    const err = error;
-    const stdoutText = err.stdout ? err.stdout.toString() : '';
-    const stderrText = err.stderr ? err.stderr.toString() : '';
-    if (stdoutText)
-        process.stderr.write(stdoutText);
-    if (stderrText)
-        process.stderr.write(stderrText);
-    throw new Error(`Command failed (exit ${err.status ?? '?'}): ${cmd}`);
-}
-function commandLabel(command, args) {
-    return [command, ...args].join(' ');
-}
-export function exec(cmd, cwd) {
-    if (VERBOSE) {
-        console.log(`  $ ${cmd}`);
-        execSync(cmd, { cwd, stdio: 'inherit' });
+    const existing = existsSync(filePath) ? readFileSync(filePath, 'utf-8') : '';
+    const existingLines = new Set(existing.split(/\r\n|\n|\r/));
+    const additions = [...new Set(lines)].filter((line) => !existingLines.has(line));
+    if (additions.length === 0)
         return;
-    }
+    const newline = existing.includes('\r\n') ? '\r\n' : existing.includes('\n') ? '\n' : existing.includes('\r') ? '\r' : '\n';
+    const separator = existing.length > 0 && !/(?:\r\n|\n|\r)$/.test(existing) ? newline : '';
+    writeFile(filePath, `${existing}${separator}${additions.join(newline)}${newline}`);
+}
+function readTail(filePath) {
+    const file = openSync(filePath, 'r');
     try {
-        execSync(cmd, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+        const size = fstatSync(file).size;
+        const length = Math.min(size, FAILURE_TAIL_BYTES);
+        if (length === 0)
+            return '';
+        const buffer = Buffer.allocUnsafe(length);
+        readSync(file, buffer, 0, length, size - length);
+        return buffer.toString();
     }
-    catch (error) {
-        dumpFailure(error, cmd);
+    finally {
+        closeSync(file);
     }
 }
-export function execCommand(command, args, cwd) {
-    const label = commandLabel(command, args);
-    if (VERBOSE) {
-        console.log(`  $ ${label}`);
-    }
-    const result = spawnSync(command, args, {
-        cwd,
-        encoding: 'utf8',
-        stdio: VERBOSE ? 'inherit' : ['ignore', 'pipe', 'pipe'],
-    });
-    if (result.status === 0) {
-        return;
+function dumpFailure(cmd, status, stdoutPath, stderrPath, spawnError) {
+    const stdoutText = readTail(stdoutPath);
+    const stderrText = readTail(stderrPath);
+    if (process.env.ANHEDRAL_QUIET !== '1') {
+        if (stdoutText)
+            process.stderr.write(stdoutText);
+        if (stderrText)
+            process.stderr.write(stderrText);
     }
-    if (!VERBOSE) {
-        if (result.stdout)
-            process.stderr.write(result.stdout);
-        if (result.stderr)
-            process.stderr.write(result.stderr);
-    }
-    throw new Error(`Command failed (exit ${result.status ?? '?'}): ${label}`);
+    throw new Error(`Command failed (exit ${status ?? '?'}): ${cmd}`, spawnError ? { cause: spawnError } : undefined);
 }
-export function execWithInput(cmd, cwd, stdinInput) {
-    if (VERBOSE) {
-        console.log(`  $ ${cmd}`);
-        execSync(cmd, { cwd, stdio: ['pipe', 'inherit', 'inherit'], input: stdinInput });
+export function execFile(executable, args, cwd) {
+    const quiet = process.env.ANHEDRAL_QUIET === '1';
+    const display = [executable, ...args].join(' ');
+    if (process.env.ANHEDRAL_VERBOSE === '1' && !quiet) {
+        console.log(`  $ ${display}`);
+        const result = spawnSync(executable, [...args], { cwd, stdio: 'inherit', shell: false });
+        if (result.error || result.status !== 0) {
+            throw new Error(`Command failed (exit ${result.status ?? '?'}): ${display}`, result.error ? { cause: result.error } : undefined);
+        }
         return;
     }
+    const captureRoot = mkdtempSync(path.join(tmpdir(), 'anhedral-exec-'));
+    const stdoutPath = path.join(captureRoot, 'stdout.log');
+    const stderrPath = path.join(captureRoot, 'stderr.log');
+    const stdout = openSync(stdoutPath, 'w');
+    const stderr = openSync(stderrPath, 'w');
     try {
-        execSync(cmd, { cwd, stdio: ['pipe', 'pipe', 'pipe'], input: stdinInput });
-    }
-    catch (error) {
-        dumpFailure(error, cmd);
-    }
-}
-function moveDirectoryContents(sourceDir, targetDir) {
-    for (const entry of readdirSync(sourceDir, { withFileTypes: true })) {
-        const sourcePath = path.join(sourceDir, entry.name);
-        const targetPath = path.join(targetDir, entry.name);
-        if (existsSync(targetPath)) {
-            if (!entry.isDirectory() || !statSync(targetPath).isDirectory()) {
-                throw new Error(`Cannot merge scaffold output because ${targetPath} already exists.`);
-            }
-            moveDirectoryContents(sourcePath, targetPath);
-            rmSync(sourcePath, { recursive: true, force: true });
-            continue;
+        const result = spawnSync(executable, [...args], {
+            cwd,
+            shell: false,
+            stdio: ['ignore', stdout, stderr],
+        });
+        closeSync(stdout);
+        closeSync(stderr);
+        if (result.error || result.status !== 0) {
+            dumpFailure(display, result.status, stdoutPath, stderrPath, result.error);
         }
-        renameSync(sourcePath, targetPath);
     }
-}
-export function liftNestedProject(root, nestedName) {
-    const nestedRoot = path.join(root, nestedName);
-    if (!existsSync(nestedRoot)) {
-        return;
-    }
-    const selfNamedChild = path.join(nestedRoot, nestedName);
-    const tempSelfNamedChild = path.join(root, `.${nestedName}.anhedral-tmp`);
-    const hasSelfNamedChild = existsSync(selfNamedChild);
-    if (hasSelfNamedChild) {
-        if (existsSync(tempSelfNamedChild)) {
-            throw new Error(`Cannot lift scaffold output because ${tempSelfNamedChild} already exists.`);
+    finally {
+        try {
+            closeSync(stdout);
         }
-        renameSync(selfNamedChild, tempSelfNamedChild);
-    }
-    moveDirectoryContents(nestedRoot, root);
-    rmSync(nestedRoot, { recursive: true, force: true });
-    if (hasSelfNamedChild) {
-        renameSync(tempSelfNamedChild, path.join(root, nestedName));
-    }
-}
-function trimOutputTail(output, maxLength = 4000) {
-    if (output.length <= maxLength) {
-        return output;
-    }
-    return output.slice(output.length - maxLength);
-}
-export async function execExpect(cmd, cwd, prompts, timeoutMs = 120_000) {
-    if (VERBOSE) {
-        console.log(`  $ ${cmd}`);
+        catch { }
+        try {
+            closeSync(stderr);
+        }
+        catch { }
+        rmSync(captureRoot, { recursive: true, force: true });
     }
-    await new Promise((resolve, reject) => {
-        const child = spawn(cmd, {
-            cwd,
-            env: process.env,
-            shell: true,
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        let combinedOutput = '';
-        let promptIndex = 0;
-        let settled = false;
-        const finish = (handler) => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            clearTimeout(timeoutId);
-            handler();
-        };
-        const maybeAnswerPrompt = () => {
-            while (promptIndex < prompts.length && combinedOutput.includes(prompts[promptIndex][0])) {
-                child.stdin.write(`${prompts[promptIndex][1]}\n`);
-                promptIndex += 1;
-            }
-        };
-        const handleChunk = (chunk, target) => {
-            const text = chunk.toString();
-            combinedOutput += text;
-            if (VERBOSE)
-                target.write(text);
-            maybeAnswerPrompt();
-        };
-        const timeoutId = setTimeout(() => {
-            child.kill('SIGTERM');
-            finish(() => {
-                reject(new Error(`Command timed out after ${timeoutMs}ms: ${cmd}\n` +
-                    `Answered ${promptIndex}/${prompts.length} prompts.\n` +
-                    `Recent output:\n${trimOutputTail(combinedOutput)}`));
-            });
-        }, timeoutMs);
-        child.stdout.on('data', (chunk) => handleChunk(chunk, process.stdout));
-        child.stderr.on('data', (chunk) => handleChunk(chunk, process.stderr));
-        child.on('error', (error) => {
-            finish(() => {
-                reject(error);
-            });
-        });
-        child.on('close', (code) => {
-            finish(() => {
-                if (code === 0) {
-                    resolve();
-                    return;
-                }
-                reject(new Error(`Command failed with exit code ${code}: ${cmd}\n` +
-                    `Answered ${promptIndex}/${prompts.length} prompts.\n` +
-                    `Recent output:\n${trimOutputTail(combinedOutput)}`));
-            });
-        });
-    });
 }

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+/** Kept in sync with package.json by tests/release checks. */
+export declare const GENERATOR_VERSION = "0.3.0";

package/dist/version.js

@@ -0,0 +1,2 @@
+/** Kept in sync with package.json by tests/release checks. */
+export const GENERATOR_VERSION = '0.3.0';

package/dist/workspace-config.d.ts

@@ -0,0 +1,11 @@
+export type WorkspacePolicy = {
+    overrides: Record<string, string>;
+    onlyBuiltDependencies: string[];
+    ignoredBuiltDependencies: string[];
+    peerDependencyRules: {
+        ignoreMissing: string[];
+        allowedVersions: Record<string, string>;
+    };
+};
+export declare function desiredWorkspacePolicy(): WorkspacePolicy;
+export declare function mergeWorkspaceFile(root: string, desiredPackages: string[], policy: WorkspacePolicy, allowGeneratedUpdates: boolean): void;