create-next-hydra 0.1.0

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import { cancel } from "@clack/prompts";
+import { runCli } from "./index.js";
+import { UserCancelledError } from "./prompts.js";
+async function main() {
+    try {
+        await runCli(process.argv);
+    }
+    catch (error) {
+        if (error instanceof UserCancelledError) {
+            process.exitCode = 1;
+            return;
+        }
+        const message = error instanceof Error ? error.message : "Unknown error";
+        cancel(message);
+        process.exitCode = 1;
+    }
+}
+main();

package/dist/clone.d.ts

@@ -0,0 +1,9 @@
+type CloneStarterOptions = {
+    repoUrl: string;
+    targetPath: string;
+    ref?: string;
+    verbose?: boolean;
+};
+export declare function cloneStarter(options: CloneStarterOptions): Promise<void>;
+export {};
+//# sourceMappingURL=clone.d.ts.map

package/dist/clone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clone.d.ts","sourceRoot":"","sources":["../src/clone.ts"],"names":[],"mappings":"AAEA,KAAK,mBAAmB,GAAG;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,wBAAsB,YAAY,CAChC,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,IAAI,CAAC,CAoBf"}

package/dist/clone.js

@@ -0,0 +1,19 @@
+import { runGit } from "./git.js";
+export async function cloneStarter(options) {
+    const verbose = options.verbose ?? false;
+    const cloneArgs = ["clone"];
+    if (verbose) {
+        cloneArgs.push("--progress");
+    }
+    if (options.ref) {
+        cloneArgs.push(options.repoUrl, options.targetPath);
+        await runGit(cloneArgs, { verbose });
+        await runGit(["checkout", options.ref], {
+            cwd: options.targetPath,
+            verbose,
+        });
+        return;
+    }
+    cloneArgs.push("--depth", "1", options.repoUrl, options.targetPath);
+    await runGit(cloneArgs, { verbose });
+}

package/dist/constants.d.ts

@@ -0,0 +1,8 @@
+import type { StarterDefinition } from "./types.js";
+export declare const CLI_NAME = "create-next-hydra";
+export declare const DEFAULT_REPO_URL = "https://github.com/jakala-na/next-hydra.git";
+export declare const DEFAULT_COMMIT_MESSAGE = "Initial commit";
+export declare const DEFAULT_PACKAGE_MANAGER = "pnpm";
+export declare const DEFAULT_STARTER: StarterDefinition;
+export declare const SANITIZE_REMOVE_PATHS: readonly [".git", "apps/docs", "pnpm-lock.yaml"];
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD,eAAO,MAAM,QAAQ,sBAAsB,CAAC;AAC5C,eAAO,MAAM,gBAAgB,gDAAgD,CAAC;AAC9E,eAAO,MAAM,sBAAsB,mBAAmB,CAAC;AACvD,eAAO,MAAM,uBAAuB,SAAS,CAAC;AAE9C,eAAO,MAAM,eAAe,EAAE,iBAG7B,CAAC;AAEF,eAAO,MAAM,qBAAqB,kDAIxB,CAAC"}

package/dist/constants.js

@@ -0,0 +1,13 @@
+export const CLI_NAME = "create-next-hydra";
+export const DEFAULT_REPO_URL = "https://github.com/jakala-na/next-hydra.git";
+export const DEFAULT_COMMIT_MESSAGE = "Initial commit";
+export const DEFAULT_PACKAGE_MANAGER = "pnpm";
+export const DEFAULT_STARTER = {
+    id: "default",
+    repoUrl: DEFAULT_REPO_URL,
+};
+export const SANITIZE_REMOVE_PATHS = [
+    ".git",
+    "apps/docs",
+    "pnpm-lock.yaml",
+];

package/dist/fs-utils.d.ts

@@ -0,0 +1,9 @@
+export declare function pathExists(targetPath: string): Promise<boolean>;
+export declare function isDirectoryEmpty(targetPath: string): Promise<boolean>;
+export declare function ensureParentDirectory(targetPath: string): Promise<void>;
+export declare function removePath(targetPath: string): Promise<void>;
+export declare function readJsonFile<T>(filePath: string): Promise<T>;
+export declare function writeJsonFile(filePath: string, value: unknown): Promise<void>;
+export declare function toDisplayPath(absolutePath: string, cwd?: string): string;
+export declare function normalizePackageName(input: string): string;
+//# sourceMappingURL=fs-utils.d.ts.map

package/dist/fs-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs-utils.d.ts","sourceRoot":"","sources":["../src/fs-utils.ts"],"names":[],"mappings":"AAkBA,wBAAsB,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAOrE;AAED,wBAAsB,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAQ3E;AAED,wBAAsB,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAI7E;AAED,wBAAsB,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAElE;AAED,wBAAsB,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAGlE;AAED,wBAAsB,aAAa,CACjC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,IAAI,CAAC,CAEf;AAED,wBAAgB,aAAa,CAC3B,YAAY,EAAE,MAAM,EACpB,GAAG,SAAgB,GAClB,MAAM,CAYR;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAiB1D"}

package/dist/fs-utils.js

@@ -0,0 +1,64 @@
+import { access, mkdir, readdir, readFile, rm, stat, writeFile, } from "node:fs/promises";
+import path from "node:path";
+const INVALID_PACKAGE_CHARS_REGEX = /[^a-z0-9._-]+/g;
+const DUPLICATE_DASHES_REGEX = /-+/g;
+const LEADING_PUNCTUATION_REGEX = /^[._-]+/;
+const TRAILING_PUNCTUATION_REGEX = /[._-]+$/;
+const PACKAGE_START_CHAR_REGEX = /^[a-z0-9]/;
+const MAX_UNSCOPED_PACKAGE_NAME_LENGTH = 214;
+export async function pathExists(targetPath) {
+    try {
+        await stat(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function isDirectoryEmpty(targetPath) {
+    const targetStat = await stat(targetPath);
+    if (!targetStat.isDirectory()) {
+        throw new Error(`Target path exists and is not a directory: ${targetPath}`);
+    }
+    const entries = await readdir(targetPath);
+    return entries.length === 0;
+}
+export async function ensureParentDirectory(targetPath) {
+    const parentDir = path.dirname(targetPath);
+    await mkdir(parentDir, { recursive: true });
+    await access(parentDir);
+}
+export async function removePath(targetPath) {
+    await rm(targetPath, { recursive: true, force: true });
+}
+export async function readJsonFile(filePath) {
+    const raw = await readFile(filePath, "utf8");
+    return JSON.parse(raw);
+}
+export async function writeJsonFile(filePath, value) {
+    await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+export function toDisplayPath(absolutePath, cwd = process.cwd()) {
+    const relative = path.relative(cwd, absolutePath);
+    if (!relative || relative === "") {
+        return ".";
+    }
+    if (relative.startsWith("..")) {
+        return absolutePath;
+    }
+    return relative;
+}
+export function normalizePackageName(input) {
+    let value = input.trim().toLowerCase();
+    value = value.replace(INVALID_PACKAGE_CHARS_REGEX, "-");
+    value = value.replace(DUPLICATE_DASHES_REGEX, "-");
+    value = value.replace(LEADING_PUNCTUATION_REGEX, "");
+    value = value.replace(TRAILING_PUNCTUATION_REGEX, "");
+    if (!value) {
+        return "next-hydra-app";
+    }
+    if (!PACKAGE_START_CHAR_REGEX.test(value)) {
+        value = `app-${value}`;
+    }
+    return value.slice(0, MAX_UNSCOPED_PACKAGE_NAME_LENGTH);
+}

package/dist/git.d.ts

@@ -0,0 +1,28 @@
+import type { GitInitResult, RunCommandResult } from "./types.js";
+type RunCommandOptions = {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    verbose?: boolean;
+};
+export declare class CommandExecutionError extends Error {
+    readonly command: string;
+    readonly code: number | null;
+    readonly stdout: string;
+    readonly stderr: string;
+    constructor(params: {
+        command: string;
+        code: number | null;
+        stdout: string;
+        stderr: string;
+        message?: string;
+    });
+}
+export declare function runCommand(command: string, args: string[], options?: RunCommandOptions): Promise<RunCommandResult>;
+export declare function runGit(args: string[], options?: RunCommandOptions): Promise<RunCommandResult>;
+export declare function ensureGitInstalled(verbose?: boolean): Promise<void>;
+export declare function initializeGitRepository(targetPath: string, options: {
+    commit: boolean;
+    verbose?: boolean;
+}): Promise<GitInitResult>;
+export {};
+//# sourceMappingURL=git.d.ts.map

package/dist/git.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git.d.ts","sourceRoot":"","sources":["../src/git.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAElE,KAAK,iBAAiB,GAAG;IACvB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,MAAM,EAAE;QAClB,OAAO,EAAE,MAAM,CAAC;QAChB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;QACpB,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB;CAQF;AAED,wBAAsB,UAAU,CAC9B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAAC,gBAAgB,CAAC,CAqD3B;AAED,wBAAgB,MAAM,CACpB,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAAC,gBAAgB,CAAC,CAQ3B;AAED,wBAAsB,kBAAkB,CAAC,OAAO,UAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAEvE;AAED,wBAAsB,uBAAuB,CAC3C,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,GAC9C,OAAO,CAAC,aAAa,CAAC,CAoCxB"}

package/dist/git.js

@@ -0,0 +1,107 @@
+import { spawn } from "node:child_process";
+import { DEFAULT_COMMIT_MESSAGE } from "./constants.js";
+import { formatCommand } from "./logger.js";
+export class CommandExecutionError extends Error {
+    command;
+    code;
+    stdout;
+    stderr;
+    constructor(params) {
+        super(params.message ?? `Command failed: ${params.command}`);
+        this.name = "CommandExecutionError";
+        this.command = params.command;
+        this.code = params.code;
+        this.stdout = params.stdout;
+        this.stderr = params.stderr;
+    }
+}
+export async function runCommand(command, args, options = {}) {
+    const child = spawn(command, args, {
+        cwd: options.cwd,
+        env: {
+            ...process.env,
+            ...options.env,
+        },
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+        const text = chunk.toString();
+        stdout += text;
+        if (options.verbose) {
+            process.stdout.write(text);
+        }
+    });
+    child.stderr.on("data", (chunk) => {
+        const text = chunk.toString();
+        stderr += text;
+        if (options.verbose) {
+            process.stderr.write(text);
+        }
+    });
+    const exitCode = await new Promise((resolve, reject) => {
+        child.on("error", reject);
+        child.on("close", resolve);
+    }).catch((error) => {
+        throw new CommandExecutionError({
+            command: formatCommand(command, args),
+            code: null,
+            stdout,
+            stderr,
+            message: error instanceof Error ? error.message : "Failed to start command",
+        });
+    });
+    if (exitCode !== 0) {
+        throw new CommandExecutionError({
+            command: formatCommand(command, args),
+            code: exitCode,
+            stdout,
+            stderr,
+        });
+    }
+    return { stdout, stderr };
+}
+export function runGit(args, options = {}) {
+    return runCommand("git", args, {
+        ...options,
+        env: {
+            GIT_TERMINAL_PROMPT: "0",
+            ...options.env,
+        },
+    });
+}
+export async function ensureGitInstalled(verbose = false) {
+    await runGit(["--version"], { verbose });
+}
+export async function initializeGitRepository(targetPath, options) {
+    const verbose = options.verbose ?? false;
+    await runGit(["init"], { cwd: targetPath, verbose });
+    if (!options.commit) {
+        return {
+            gitInitialized: true,
+            committed: false,
+        };
+    }
+    await runGit(["add", "-A"], { cwd: targetPath, verbose });
+    try {
+        await runGit(["commit", "-m", DEFAULT_COMMIT_MESSAGE], {
+            cwd: targetPath,
+            verbose,
+        });
+        return {
+            gitInitialized: true,
+            committed: true,
+        };
+    }
+    catch (error) {
+        if (error instanceof CommandExecutionError) {
+            return {
+                gitInitialized: true,
+                committed: false,
+                commitError: error.stderr.trim() || error.stdout.trim() || error.message,
+            };
+        }
+        throw error;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export declare function runCli(argv?: string[]): Promise<void>;
+export type { CreateOptions, ResolvedCreateOptions, ScaffoldResult, StarterDefinition, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AA+BA,wBAAsB,MAAM,CAAC,IAAI,WAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAoC/D;AACD,YAAY,EACV,aAAa,EACb,qBAAqB,EACrB,cAAc,EACd,iBAAiB,GAClB,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,40 @@
+import { Command } from "commander";
+import { CLI_NAME, DEFAULT_REPO_URL } from "./constants.js";
+import { promptForTargetDirectory } from "./prompts.js";
+import { scaffoldProject } from "./scaffold.js";
+function buildCreateOptions(targetDir, rawOptions) {
+    return {
+        targetDir,
+        yes: rawOptions.yes ?? false,
+        skipGit: rawOptions.skipGit ?? false,
+        commit: rawOptions.commit ?? true,
+        ref: rawOptions.ref,
+        repoUrl: rawOptions.repoUrl ?? DEFAULT_REPO_URL,
+        verbose: rawOptions.verbose ?? false,
+    };
+}
+export async function runCli(argv = process.argv) {
+    const program = new Command();
+    program
+        .name(CLI_NAME)
+        .description("Scaffold a new next-hydra project")
+        .argument("[project-directory]", "Target directory")
+        .option("-y, --yes", "Skip prompts (requires [project-directory])")
+        .option("--skip-git", "Skip git initialization")
+        .option("--no-commit", "Initialize git but skip initial commit")
+        .option("--ref <git-ref>", "Clone and checkout a specific git ref")
+        .option("--repo-url <url>", "Override the starter repo URL")
+        .option("--verbose", "Print git command output")
+        .version("0.1.0")
+        .action(async (projectDirectory, rawOptions) => {
+        let targetDir = projectDirectory?.trim();
+        if (!targetDir) {
+            if (rawOptions.yes) {
+                throw new Error("`--yes` requires a target directory, e.g. `create-next-hydra my-app --yes`.");
+            }
+            targetDir = await promptForTargetDirectory();
+        }
+        await scaffoldProject(buildCreateOptions(targetDir, rawOptions));
+    });
+    await program.parseAsync(argv);
+}

package/dist/logger.d.ts

@@ -0,0 +1,12 @@
+export declare function info(message: string): void;
+export declare function warn(message: string): void;
+export declare function success(message: string): void;
+export declare function printNextSteps(message: string, title?: string): void;
+export declare function finish(message: string): void;
+export declare function createSpinner(): {
+    start: (msg?: string) => void;
+    stop: (msg?: string, code?: number) => void;
+    message: (msg?: string) => void;
+};
+export declare function formatCommand(command: string, args: string[]): string;
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAEA,wBAAgB,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE1C;AAED,wBAAgB,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE1C;AAED,wBAAgB,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE7C;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,SAAe,GAAG,IAAI,CAE1E;AAED,wBAAgB,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE5C;AAED,wBAAgB,aAAa;eAO4uG,CAAC;cAAiC,CAAC,cAAc,CAAC;iBAAoC,CAAC;EAL/1G;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAErE"}

package/dist/logger.js

@@ -0,0 +1,22 @@
+import { log, note, outro, spinner } from "@clack/prompts";
+export function info(message) {
+    log.info(message);
+}
+export function warn(message) {
+    log.warn(message);
+}
+export function success(message) {
+    log.success(message);
+}
+export function printNextSteps(message, title = "Next steps") {
+    note(message, title);
+}
+export function finish(message) {
+    outro(message);
+}
+export function createSpinner() {
+    return spinner();
+}
+export function formatCommand(command, args) {
+    return [command, ...args].join(" ");
+}

package/dist/prompts.d.ts

@@ -0,0 +1,5 @@
+export declare class UserCancelledError extends Error {
+    constructor();
+}
+export declare function promptForTargetDirectory(): Promise<string>;
+//# sourceMappingURL=prompts.d.ts.map

package/dist/prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../src/prompts.ts"],"names":[],"mappings":"AAEA,qBAAa,kBAAmB,SAAQ,KAAK;;CAK5C;AAED,wBAAsB,wBAAwB,IAAI,OAAO,CAAC,MAAM,CAAC,CAmBhE"}

package/dist/prompts.js

@@ -0,0 +1,24 @@
+import { cancel, isCancel, text } from "@clack/prompts";
+export class UserCancelledError extends Error {
+    constructor() {
+        super("Operation cancelled by user.");
+        this.name = "UserCancelledError";
+    }
+}
+export async function promptForTargetDirectory() {
+    const result = await text({
+        message: "Where should the project be created?",
+        placeholder: "my-next-hydra-app",
+        validate(value) {
+            if (!value?.trim()) {
+                return "Please enter a folder name.";
+            }
+            return undefined;
+        },
+    });
+    if (isCancel(result)) {
+        cancel("Cancelled.");
+        throw new UserCancelledError();
+    }
+    return result.trim();
+}

package/dist/sanitize.d.ts

@@ -0,0 +1,9 @@
+type SanitizeStarterOptions = {
+    targetPath: string;
+    targetName: string;
+};
+export declare function sanitizeStarter({ targetPath, targetName, }: SanitizeStarterOptions): Promise<{
+    packageName: string;
+}>;
+export {};
+//# sourceMappingURL=sanitize.d.ts.map

package/dist/sanitize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../src/sanitize.ts"],"names":[],"mappings":"AASA,KAAK,sBAAsB,GAAG;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAOF,wBAAsB,eAAe,CAAC,EACpC,UAAU,EACV,UAAU,GACX,EAAE,sBAAsB,GAAG,OAAO,CAAC;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC,CAc3D"}

package/dist/sanitize.js

@@ -0,0 +1,14 @@
+import path from "node:path";
+import { SANITIZE_REMOVE_PATHS } from "./constants.js";
+import { normalizePackageName, readJsonFile, removePath, writeJsonFile, } from "./fs-utils.js";
+export async function sanitizeStarter({ targetPath, targetName, }) {
+    for (const relativePath of SANITIZE_REMOVE_PATHS) {
+        await removePath(path.join(targetPath, relativePath));
+    }
+    const packageJsonPath = path.join(targetPath, "package.json");
+    const packageJson = await readJsonFile(packageJsonPath);
+    const packageName = normalizePackageName(targetName);
+    packageJson.name = packageName;
+    await writeJsonFile(packageJsonPath, packageJson);
+    return { packageName };
+}

package/dist/scaffold.d.ts

@@ -0,0 +1,3 @@
+import type { CreateOptions, ScaffoldResult } from "./types.js";
+export declare function scaffoldProject(options: CreateOptions): Promise<ScaffoldResult>;
+//# sourceMappingURL=scaffold.d.ts.map

package/dist/scaffold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scaffold.d.ts","sourceRoot":"","sources":["../src/scaffold.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EACV,aAAa,EAEb,cAAc,EACf,MAAM,YAAY,CAAC;AA8EpB,wBAAsB,eAAe,CACnC,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,cAAc,CAAC,CAyGzB"}

package/dist/scaffold.js

@@ -0,0 +1,149 @@
+import path from "node:path";
+import { intro } from "@clack/prompts";
+import { cloneStarter } from "./clone.js";
+import { DEFAULT_PACKAGE_MANAGER } from "./constants.js";
+import { ensureParentDirectory, isDirectoryEmpty, pathExists, removePath, toDisplayPath, } from "./fs-utils.js";
+import { CommandExecutionError, ensureGitInstalled, initializeGitRepository, } from "./git.js";
+import { createSpinner, finish, info, printNextSteps, success, warn, } from "./logger.js";
+import { sanitizeStarter } from "./sanitize.js";
+const SHELL_NEEDS_QUOTING_REGEX = /[\s"'\\]/;
+function quotePathForShell(value) {
+    if (!SHELL_NEEDS_QUOTING_REGEX.test(value)) {
+        return value;
+    }
+    return `'${value.replace(/'/g, `'\"'\"'`)}'`;
+}
+async function resolveAndValidateTarget(inputTargetDir) {
+    const targetDir = inputTargetDir.trim();
+    const targetPath = path.resolve(process.cwd(), targetDir);
+    const targetName = path.basename(targetPath);
+    if (!targetName) {
+        throw new Error("Please provide a valid target folder.");
+    }
+    const existedBefore = await pathExists(targetPath);
+    if (existedBefore) {
+        const isEmpty = await isDirectoryEmpty(targetPath);
+        if (!isEmpty) {
+            throw new Error(`Target directory is not empty: ${toDisplayPath(targetPath)}`);
+        }
+    }
+    else {
+        await ensureParentDirectory(targetPath);
+    }
+    return { targetDir, targetName, targetPath, existedBefore };
+}
+function formatGitError(error) {
+    const isCloneCommand = error.command.startsWith("git clone ");
+    const stderr = error.stderr.trim();
+    if (stderr) {
+        if (!isCloneCommand) {
+            return `${error.command}\n\n${stderr}`;
+        }
+        return [
+            error.command,
+            "",
+            stderr,
+            "",
+            "Hint: If the starter repo is private or you are testing locally, use `--repo-url`.",
+            "Example: create-next-hydra my-app --repo-url /path/to/next-hydra",
+        ].join("\n");
+    }
+    const stdout = error.stdout.trim();
+    if (stdout) {
+        if (!isCloneCommand) {
+            return `${error.command}\n\n${stdout}`;
+        }
+        return [
+            error.command,
+            "",
+            stdout,
+            "",
+            "Hint: If the starter repo is private or you are testing locally, use `--repo-url`.",
+            "Example: create-next-hydra my-app --repo-url /path/to/next-hydra",
+        ].join("\n");
+    }
+    return `${error.command}\n\n${error.message}`;
+}
+export async function scaffoldProject(options) {
+    intro("create-next-hydra");
+    const spin = createSpinner();
+    const { repoUrl, ref, skipGit, commit, verbose } = options;
+    const targetDir = options.targetDir;
+    if (!targetDir) {
+        throw new Error("Missing target directory.");
+    }
+    spin.start("Checking git availability");
+    try {
+        await ensureGitInstalled(verbose);
+        spin.stop("Git detected");
+    }
+    catch {
+        spin.stop("Git not available");
+        throw new Error("Git is required to scaffold a project. Please install git and try again.");
+    }
+    const { targetPath, targetName, existedBefore } = await resolveAndValidateTarget(targetDir);
+    let cloneCompleted = false;
+    try {
+        spin.start("Cloning next-hydra starter");
+        await cloneStarter({
+            repoUrl,
+            targetPath,
+            ref,
+            verbose,
+        });
+        cloneCompleted = true;
+        spin.stop("Starter cloned");
+        spin.start("Sanitizing starter");
+        const { packageName } = await sanitizeStarter({ targetPath, targetName });
+        spin.stop("Starter sanitized");
+        let gitInitialized = false;
+        let committed = false;
+        if (skipGit) {
+            info("Skipped git initialization (--skip-git).");
+        }
+        else {
+            spin.start(commit
+                ? "Initializing git repo and creating initial commit"
+                : "Initializing git repo");
+            const gitResult = await initializeGitRepository(targetPath, {
+                commit,
+                verbose,
+            });
+            gitInitialized = gitResult.gitInitialized;
+            committed = gitResult.committed;
+            spin.stop(committed
+                ? "Git repo initialized with initial commit"
+                : "Git repo initialized");
+            if (gitResult.commitError) {
+                warn(`Project was scaffolded, but the initial commit failed. You can commit manually.\n${gitResult.commitError}`);
+            }
+        }
+        const displayTarget = toDisplayPath(targetPath);
+        const cdTarget = quotePathForShell(displayTarget);
+        printNextSteps([
+            `cd ${cdTarget}`,
+            `${DEFAULT_PACKAGE_MANAGER} install`,
+            `${DEFAULT_PACKAGE_MANAGER} dev`,
+        ].join("\n"));
+        success(`Created project in ${displayTarget}`);
+        finish("Scaffold complete.");
+        return {
+            projectPath: targetPath,
+            packageName,
+            gitInitialized,
+            committed,
+        };
+    }
+    catch (error) {
+        if (cloneCompleted === false && existedBefore === false) {
+            await removePath(targetPath);
+        }
+        if (error instanceof CommandExecutionError) {
+            throw new Error(formatGitError(error));
+        }
+        if (error instanceof Error) {
+            throw error;
+        }
+        throw new Error("Failed to scaffold project.");
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,35 @@
+export type CreateOptions = {
+    targetDir?: string;
+    yes: boolean;
+    skipGit: boolean;
+    commit: boolean;
+    ref?: string;
+    repoUrl: string;
+    verbose: boolean;
+};
+export type ResolvedCreateOptions = CreateOptions & {
+    targetDir: string;
+    targetPath: string;
+    targetName: string;
+};
+export type StarterDefinition = {
+    id: string;
+    repoUrl: string;
+    defaultRef?: string;
+};
+export type ScaffoldResult = {
+    projectPath: string;
+    packageName: string;
+    gitInitialized: boolean;
+    committed: boolean;
+};
+export type GitInitResult = {
+    gitInitialized: boolean;
+    committed: boolean;
+    commitError?: string;
+};
+export type RunCommandResult = {
+    stdout: string;
+    stderr: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GAAG;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,OAAO,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,aAAa,GAAG;IAClD,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,OAAO,CAAC;IACxB,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,cAAc,EAAE,OAAO,CAAC;IACxB,SAAS,EAAE,OAAO,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "create-next-hydra",
+  "version": "0.1.0",
+  "description": "CLI to scaffold a new next-hydra project",
+  "keywords": [
+    "cli",
+    "create-next-app",
+    "create-next-hydra",
+    "next-hydra",
+    "scaffold",
+    "starter",
+    "turborepo"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "create-next-hydra": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./cli": {
+      "import": "./dist/cli.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "pack": "npm pack",
+    "publish:dry-run": "npm publish --access public --dry-run",
+    "publish:public": "npm publish --access public",
+    "prepublishOnly": "pnpm run build"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.11.0",
+    "commander": "^14.0.0"
+  },
+  "devDependencies": {
+    "@repo/typescript-config": "workspace:*",
+    "@types/node": "^22.15.21",
+    "typescript": "^5.8.3"
+  }
+}