anhedral 0.1.0

package/dist/toolchain.d.ts

@@ -0,0 +1,14 @@
+export declare const TOOLCHAIN_CHANNELS: readonly ["latest", "stable"];
+export type ToolchainChannel = (typeof TOOLCHAIN_CHANNELS)[number];
+export type ToolchainSpec = {
+    verifiedAt: string | null;
+    viteCreate: string;
+    shadcn: string;
+    reactNativeReusables: string;
+    wxt: string;
+    tauriCli: string;
+    tauriApi: string;
+};
+export declare function resolveToolchainChannel(value: string | undefined): ToolchainChannel;
+export declare function resolveToolchain(channel: ToolchainChannel): ToolchainSpec;
+export declare function toolPackageRef(pkg: string, versionTag: string): string;

package/dist/toolchain.js

@@ -0,0 +1,34 @@
+export const TOOLCHAIN_CHANNELS = ['latest', 'stable'];
+const TOOLCHAIN_SPECS = {
+    latest: {
+        verifiedAt: null,
+        viteCreate: 'latest',
+        shadcn: 'latest',
+        reactNativeReusables: 'latest',
+        wxt: 'latest',
+        tauriCli: 'latest',
+        tauriApi: 'latest',
+    },
+    stable: {
+        verifiedAt: '2026-03-22',
+        viteCreate: '7.1.4',
+        shadcn: '4.1.0',
+        reactNativeReusables: '0.5.0',
+        wxt: '0.20.20',
+        tauriCli: '2.8.4',
+        tauriApi: '2.8.0',
+    },
+};
+export function resolveToolchainChannel(value) {
+    if (!value)
+        return 'stable';
+    if (value === 'latest' || value === 'stable')
+        return value;
+    throw new Error(`--toolchain must be one of: ${TOOLCHAIN_CHANNELS.join(', ')}`);
+}
+export function resolveToolchain(channel) {
+    return TOOLCHAIN_SPECS[channel];
+}
+export function toolPackageRef(pkg, versionTag) {
+    return `${pkg}@${versionTag}`;
+}

package/dist/util.d.ts

@@ -0,0 +1,6 @@
+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 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][]): void;

package/dist/util.js

@@ -0,0 +1,99 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+import path from 'node:path';
+export function writeFile(filePath, content) {
+    mkdirSync(path.dirname(filePath), { recursive: true });
+    writeFileSync(filePath, content, 'utf-8');
+}
+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');
+}
+export function exec(cmd, cwd) {
+    console.log(`  $ ${cmd}`);
+    execSync(cmd, { cwd, stdio: 'inherit' });
+}
+export function execWithInput(cmd, cwd, stdinInput) {
+    console.log(`  $ ${cmd}`);
+    execSync(cmd, { cwd, stdio: ['pipe', 'inherit', 'inherit'], input: stdinInput });
+}
+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;
+        }
+        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.`);
+        }
+        renameSync(selfNamedChild, tempSelfNamedChild);
+    }
+    moveDirectoryContents(nestedRoot, root);
+    rmSync(nestedRoot, { recursive: true, force: true });
+    if (hasSelfNamedChild) {
+        renameSync(tempSelfNamedChild, path.join(root, nestedName));
+    }
+}
+function bashSingleQuoteEscape(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function tclDoubleQuoteEscape(value) {
+    return value
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"')
+        .replace(/\[/g, '\\[')
+        .replace(/\]/g, '\\]')
+        .replace(/\$/g, '\\$')
+        .replace(/\r/g, '\\r')
+        .replace(/\n/g, '\\n');
+}
+/**
+ * Escape a string for use inside a Tcl double-quoted `send` argument.
+ * Converts JS escape sequences to their Tcl equivalents.
+ */
+function tclSendEscape(s) {
+    return tclDoubleQuoteEscape(s).replace(/\x1b/g, '\\033');
+}
+export function execExpect(cmd, cwd, prompts) {
+    console.log(`  $ ${cmd}`);
+    const shellCommand = `cd ${bashSingleQuoteEscape(cwd)} && ${cmd}`;
+    const sendLines = prompts
+        .map(([wait, answer]) => `expect "${wait}"\nsend "${tclSendEscape(answer)}\\r"`)
+        .join('\n');
+    const expectScript = [
+        `set timeout 120`,
+        `set shell_command "${tclDoubleQuoteEscape(shellCommand)}"`,
+        `spawn bash -lc $shell_command`,
+        sendLines,
+        `expect eof`,
+        `catch wait result`,
+        `exit [lindex $result 3]`,
+    ].join('\n');
+    execSync(`expect << 'EXPECT_EOF'\n${expectScript}\nEXPECT_EOF`, {
+        cwd,
+        stdio: 'inherit',
+        shell: '/bin/bash',
+    });
+}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "anhedral",
+  "version": "0.1.0",
+  "description": "Opinionated init CLI for Next, Next + Fastify, Expo + Fastify, and backend starters with Neon, Drizzle, R2, auth, and billing integrations.",
+  "type": "module",
+  "bin": {
+    "anhedral": "./bin/anhedral.js"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "LICENSE",
+    "README.md",
+    "anhedral.svg"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/anhedral/anhedral-init.git"
+  },
+  "homepage": "https://github.com/anhedral/anhedral-init#readme",
+  "bugs": {
+    "url": "https://github.com/anhedral/anhedral-init/issues"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "scripts": {
+    "scaffold": "node dist/index.js init",
+    "build": "tsc",
+    "prepare": "pnpm build",
+    "typecheck": "tsc --noEmit",
+    "test": "pnpm test:cli",
+    "pretest": "pnpm build",
+    "prepublishOnly": "pnpm test:all",
+    "test:cli": "node scripts/test-cli.js",
+    "test:cli:validation": "node scripts/test-cli-validation.js",
+    "test:cli:scaffold": "node scripts/test-cli-scaffold-headless.js",
+    "test:e2e": "node scripts/test-e2e-public-stacks.js",
+    "test:all": "pnpm test && pnpm test:e2e"
+  },
+  "keywords": [
+    "cli",
+    "scaffold",
+    "fastify",
+    "expo",
+    "clerk",
+    "drizzle",
+    "neondb",
+    "revenuecat",
+    "better-auth",
+    "shadcn"
+  ],
+  "license": "MIT",
+  "packageManager": "pnpm@10.15.1",
+  "devDependencies": {
+    "@types/node": "^24.5.2",
+    "tsx": "^4.20.5",
+    "typescript": "^5.9.2"
+  }
+}