create-next-hydra 0.3.0 → 0.4.1

package/dist/errors.js

@@ -0,0 +1,140 @@
+import { Runtime, Schema } from "effect";
+export class ApplicationTaskFailed extends Schema.TaggedError()("ApplicationTaskFailed", {
+    code: Schema.Int,
+    directory: Schema.String,
+}) {
+    get message() {
+        return `Application task failed in ${this.directory} (exit ${this.code}).`;
+    }
+    get [Runtime.errorExitCode]() {
+        return this.code;
+    }
+}
+export class IncompatibleSelection extends Schema.TaggedError()("IncompatibleSelection", {
+    conflicts: Schema.Array(Schema.String),
+    missing: Schema.Array(Schema.String),
+    selection: Schema.String,
+}) {
+    get message() {
+        const reasons = [];
+        if (this.missing.length) {
+            reasons.push(`requires ${this.missing.join(", ")}`);
+        }
+        if (this.conflicts.length) {
+            reasons.push(`conflicts with ${this.conflicts.join(", ")}`);
+        }
+        return `${this.selection} ${reasons.join("; ")}`;
+    }
+}
+export class InvalidComposition extends Schema.TaggedError()("InvalidComposition", { message: Schema.String }) {
+}
+export class SourceChanged extends Schema.TaggedError()("SourceChanged", { paths: Schema.Array(Schema.String) }) {
+}
+export class SourceAcquisitionFailed extends Schema.TaggedError()("SourceAcquisitionFailed", { diagnostic: Schema.Redacted(Schema.Unknown), phase: Schema.String }) {
+    get message() {
+        return `Source acquisition failed during ${this.phase}; no application files were published.`;
+    }
+}
+export class SourceStorageRetained extends Schema.TaggedError()("SourceStorageRetained", { directory: Schema.String }) {
+}
+export class DestinationNotEmpty extends Schema.TaggedError()("DestinationNotEmpty", { directory: Schema.String }) {
+}
+export class RegistryFailure extends Schema.TaggedError()("RegistryFailure", { diagnostic: Schema.Redacted(Schema.String), operation: Schema.String }) {
+}
+export class StagingRetained extends Schema.TaggedError()("StagingRetained", { directory: Schema.String }) {
+}
+export class RegistryWorkerFailure extends Schema.TaggedError()("RegistryWorkerFailure", { phase: Schema.Literals(["launch", "exit", "protocol", "stop"]) }) {
+}
+export class MaterializationFailed extends Schema.TaggedError()("MaterializationFailed", {
+    completedFiles: Schema.Array(Schema.String),
+    diagnostic: Schema.Redacted(Schema.Unknown),
+    directory: Schema.String,
+    failedFile: Schema.String,
+}) {
+}
+export class EnvironmentInitializationFailed extends Schema.TaggedError()("EnvironmentInitializationFailed", {
+    createdFiles: Schema.Array(Schema.String),
+    diagnostic: Schema.Redacted(Schema.Unknown),
+    directory: Schema.String,
+    failedFile: Schema.String,
+}) {
+    get message() {
+        return `Environment initialization failed at ${this.failedFile}. Application files may already be present. Preserve and inspect this file before retrying; it may be incomplete.`;
+    }
+}
+export class WorkspaceBusy extends Schema.TaggedError()("WorkspaceBusy", { directory: Schema.String }) {
+    get message() {
+        return `Workspace write lock exists: ${this.directory}. Another operation may be running or may have stopped unexpectedly; no files were changed.`;
+    }
+}
+export class WorkspaceLockAuthorizationRequired extends Schema.TaggedError()("WorkspaceLockAuthorizationRequired", { directory: Schema.String, reason: Schema.String, token: Schema.String }) {
+    get message() {
+        return `Lock recovery needs authorization in ${this.directory}: ${this.reason}. Run Compose in an interactive terminal to authorize breaking this lock. Files and recovery evidence have been preserved.`;
+    }
+}
+export class WorkspaceLockChanged extends Schema.TaggedError()("WorkspaceLockChanged", { directory: Schema.String }) {
+    get message() {
+        return `The lock in ${this.directory} changed. This operation cannot continue; run Compose again to inspect the current lock.`;
+    }
+}
+export class WorkspaceConflict extends Schema.TaggedError()("WorkspaceConflict", { paths: Schema.Array(Schema.String) }) {
+    get message() {
+        return `Refresh blocked by local changes: ${this.paths.join(", ")}`;
+    }
+}
+export class WorkspaceRecoveryRequired extends Schema.TaggedError()("WorkspaceRecoveryRequired", {
+    directory: Schema.String,
+    paths: Schema.optionalKey(Schema.Array(Schema.String)),
+}) {
+    get message() {
+        if (this.paths !== undefined && this.paths.length > 0) {
+            return `Initialization needs inspection in ${this.directory}: ${this.paths.join(", ")}. A write started but completion was not recorded. Preserve and inspect these files; they may be incomplete.`;
+        }
+        return `An incomplete workspace operation needs inspection: ${this.directory}. Files have been preserved; unresolved initialization, installation or write coordination cannot be recovered automatically.`;
+    }
+}
+export class WorkspaceStateInvalid extends Schema.TaggedError()("WorkspaceStateInvalid", { directory: Schema.String }) {
+    get message() {
+        return `Workspace ownership state is invalid or has changed: ${this.directory}. No ownership was inferred from application files.`;
+    }
+}
+export class WorkspaceNotCurrent extends Schema.TaggedError()("WorkspaceNotCurrent", { directory: Schema.String }) {
+    get message() {
+        return `Workspace needs attention: ${this.directory}. Check did not change any files or install dependencies.`;
+    }
+}
+export class WorkspaceBatchFailed extends Schema.TaggedError()("WorkspaceBatchFailed", { names: Schema.Array(Schema.String) }) {
+    get message() {
+        return `Workspaces needing attention: ${this.names.join(", ")}. Other workspaces were processed independently; rerun after resolving the reported issues.`;
+    }
+}
+export class SnapshotUnavailable extends Schema.TaggedError()("SnapshotUnavailable", { directory: Schema.String }) {
+    get message() {
+        return `No usable composition snapshot for ${this.directory}. Existing files remain untouched; synchronize only after reconciling local edits.`;
+    }
+}
+export class WorkspaceUninitialized extends Schema.TaggedError()("WorkspaceUninitialized", { directory: Schema.String }) {
+    get message() {
+        return `No recorded composition exists for ${this.directory}. Existing application files were not adopted.`;
+    }
+}
+export class SnapshotFailed extends Schema.TaggedError()("SnapshotFailed", { directory: Schema.String, operation: Schema.String }) {
+    get message() {
+        return `Composition snapshot ${this.operation} failed for ${this.directory}. The saved baseline was not advanced.`;
+    }
+}
+export class DependencyInstallationFailed extends Schema.TaggedError()("DependencyInstallationFailed", {
+    directory: Schema.String,
+    phase: Schema.Literals([
+        "launch",
+        "exit",
+        "stop",
+        "inputs",
+        "outputs",
+        "version",
+    ]),
+}) {
+    get message() {
+        return `Dependency installation failed (${this.phase}) in ${this.directory}. Application files remain applied; dependencies are not current.`;
+    }
+}

package/dist/file-policy.d.ts

@@ -0,0 +1,6 @@
+export declare const cacheDirectories: ReadonlySet<string>;
+export declare function environmentFileType(target: string): "runtime" | "example" | undefined;
+export declare function isEnvironmentFile(target: string): boolean;
+export declare function isCanonicalSource(file: string): boolean;
+export declare function eligiblePackageFile(file: string): boolean;
+//# sourceMappingURL=file-policy.d.ts.map

package/dist/file-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-policy.d.ts","sourceRoot":"","sources":["../src/file-policy.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,gBAAgB,EAAE,WAAW,CAAC,MAAM,CAQ/C,CAAC;AAIH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,GACb,SAAS,GAAG,SAAS,GAAG,SAAS,CAQnC;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAYvD;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAQzD"}

package/dist/file-policy.js

@@ -0,0 +1,38 @@
+// Classification is shared; each operation still decides which categories it owns.
+export const cacheDirectories = new Set([
+    "node_modules",
+    "dist",
+    ".next",
+    ".turbo",
+    ".cache",
+    ".swc",
+    ".vercel",
+]);
+const environmentExamples = [".example", ".sample", ".template"];
+export function environmentFileType(target) {
+    const name = target.slice(target.lastIndexOf("/") + 1);
+    if (name !== ".env" && !name.startsWith(".env.")) {
+        return undefined;
+    }
+    return environmentExamples.some((suffix) => name.endsWith(suffix))
+        ? "example"
+        : "runtime";
+}
+export function isEnvironmentFile(target) {
+    return environmentFileType(target) === "runtime";
+}
+export function isCanonicalSource(file) {
+    const parts = file.split("/");
+    return (parts[0] !== "workspaces" &&
+        !parts.some((part) => part === ".git" ||
+            cacheDirectories.has(part) ||
+            part.startsWith(".workspace-composition")) &&
+        !isEnvironmentFile(file));
+}
+export function eligiblePackageFile(file) {
+    const name = file.slice(file.lastIndexOf("/") + 1);
+    return (!file.includes("/registry/") &&
+        name !== "registry.json" &&
+        !name.endsWith(".template") &&
+        !isEnvironmentFile(file));
+}

package/dist/files.d.ts

@@ -0,0 +1,7 @@
+import { Effect, FileSystem, Path } from "effect";
+import { InvalidComposition } from "./errors.ts";
+import type { PreparedFile } from "./model.ts";
+export declare const relativeFile: (input: string) => Effect.Effect<string, InvalidComposition>;
+export declare const writeFile: (root: string, file: PreparedFile, exclusive?: boolean | undefined) => Effect.Effect<void, InvalidComposition | import("effect/PlatformError").PlatformError, FileSystem.FileSystem | Path.Path>;
+export declare const collectFiles: (root: string) => Effect.Effect<PreparedFile[], InvalidComposition | import("effect/PlatformError").PlatformError, FileSystem.FileSystem | Path.Path>;
+//# sourceMappingURL=files.d.ts.map

package/dist/files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"files.d.ts","sourceRoot":"","sources":["../src/files.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAElD,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C,eAAO,MAAM,YAAY,GACvB,OAAO,MAAM,KACZ,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAc1C,CAAC;AAEF,eAAO,MAAM,SAAS,kMAmBpB,CAAC;AAEH,eAAO,MAAM,YAAY,uJAkCvB,CAAC"}

package/dist/files.js

@@ -0,0 +1,66 @@
+import { Effect, FileSystem, Path } from "effect";
+import { InvalidComposition } from "./errors.js";
+export const relativeFile = (input) => {
+    const value = input.startsWith("~/") ? input.slice(2) : input;
+    return value.length === 0 ||
+        value
+            .split("/")
+            .some((part) => ["", ".", "..", ".git", "node_modules"].includes(part)) ||
+        /[:\\]/u.test(value) ||
+        value.includes(String.fromCodePoint(0))
+        ? Effect.fail(new InvalidComposition({
+            message: `Expected a workspace-relative file: ${input}`,
+        }))
+        : Effect.succeed(value);
+};
+export const writeFile = Effect.fn("Composition.writeFile")(function* (root, file, exclusive) {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const target = path.join(root, yield* relativeFile(file.target));
+    // Join each mutation before its storage owner can release the directory.
+    yield* fs
+        .makeDirectory(path.dirname(target), { recursive: true })
+        .pipe(Effect.uninterruptible);
+    yield* fs
+        .writeFile(target, file.content, {
+        flag: exclusive === true ? "wx" : "w",
+        mode: file.mode,
+    })
+        .pipe(Effect.uninterruptible);
+    yield* fs.chmod(target, file.mode).pipe(Effect.uninterruptible);
+});
+export const collectFiles = Effect.fn("Composition.collectFiles")(function* (root) {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const files = [];
+    const pending = [""];
+    while (pending.length > 0) {
+        const directory = pending.pop();
+        if (directory === undefined) {
+            break;
+        }
+        for (const name of yield* fs
+            .readDirectory(path.join(root, directory))
+            .pipe(Effect.uninterruptible)) {
+            const target = directory ? `${directory}/${name}` : name;
+            const absolute = path.join(root, target);
+            const stat = yield* fs.stat(absolute).pipe(Effect.uninterruptible);
+            if (stat.type === "Directory") {
+                pending.push(target);
+            }
+            else if (stat.type === "File") {
+                files.push({
+                    content: yield* fs.readFile(absolute).pipe(Effect.uninterruptible),
+                    mode: stat.mode % 0o1000,
+                    target,
+                });
+            }
+            else {
+                return yield* new InvalidComposition({
+                    message: `Unsupported materialized entry: ${target}`,
+                });
+            }
+        }
+    }
+    return files;
+});

package/dist/hosting.d.ts

@@ -0,0 +1,5 @@
+import { Effect, Schema } from "effect";
+import { InvalidComposition } from "./errors.ts";
+import type { PreparedFile } from "./model.ts";
+export declare const scopeApplicationHosts: (files: readonly PreparedFile[], name: string, opaqueTargets: ReadonlySet<string>, port?: number | undefined) => Effect.Effect<PreparedFile[], InvalidComposition | Schema.SchemaError, never>;
+//# sourceMappingURL=hosting.d.ts.map

package/dist/hosting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hosting.d.ts","sourceRoot":"","sources":["../src/hosting.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGxC,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AA2B/C,eAAO,MAAM,qBAAqB,gMAyHhC,CAAC"}

package/dist/hosting.js

@@ -0,0 +1,107 @@
+import { isUtf8 } from "node:buffer";
+import { Effect, Schema } from "effect";
+import { yamlDocument } from "./baseline.js";
+import { InvalidComposition } from "./errors.js";
+import { DevelopmentPort } from "./model.js";
+const extras = [Schema.Record(Schema.String, Schema.Unknown)];
+const DdevConfig = Schema.Struct({
+    name: Schema.optionalKey(Schema.NonEmptyString),
+    project_tld: Schema.optionalKey(Schema.NonEmptyString),
+});
+const Manifest = Schema.fromJsonString(Schema.StructWithRest(Schema.Struct({
+    portless: Schema.optionalKey(Schema.StructWithRest(Schema.Struct({
+        name: Schema.optionalKey(Schema.String),
+        script: Schema.String,
+    }), extras)),
+    scripts: Schema.optionalKey(Schema.Record(Schema.String, Schema.String)),
+}), extras), { space: 2 });
+export const scopeApplicationHosts = Effect.fn("Composition.scopeApplicationHosts")(function* (files, name, opaqueTargets, port) {
+    if (port !== undefined) {
+        yield* Schema.decodeEffect(DevelopmentPort)(port);
+    }
+    const namespace = name
+        .replaceAll(/[._]/gu, "-")
+        .slice(0, 63)
+        .replace(/-+$/u, "");
+    const hosts = new Map();
+    const output = [];
+    let ddevTarget;
+    for (const file of files) {
+        if (!opaqueTargets.has(file.target) &&
+            /^apps\/[^/]+\/\.ddev\/config\.yaml$/u.test(file.target)) {
+            if (ddevTarget !== undefined) {
+                return yield* new InvalidComposition({
+                    message: `Only one DDEV app can use the application name: ${ddevTarget}, ${file.target}`,
+                });
+            }
+            ddevTarget = file.target;
+            const { data, document } = yield* yamlDocument(file.content, file.target, DdevConfig);
+            const originalName = data.name ?? file.target.split("/")[1];
+            const tld = data.project_tld ?? "ddev.site";
+            hosts.set(`${originalName}.${tld}`, `${namespace}.${tld}`);
+            document.set("name", namespace);
+            output.push({
+                ...file,
+                content: new TextEncoder().encode(document.toString()),
+            });
+            continue;
+        }
+        if (opaqueTargets.has(file.target) ||
+            !/^apps\/[^/]+\/package\.json$/u.test(file.target)) {
+            output.push(file);
+            continue;
+        }
+        const manifest = yield* Schema.decodeEffect(Manifest)(new TextDecoder().decode(file.content));
+        if (!manifest.portless) {
+            output.push(file);
+            continue;
+        }
+        const scripts = manifest.scripts ?? {};
+        if (!(scripts.dev === "portless" || scripts.dev?.startsWith("portless ")) ||
+            manifest.portless.script === "dev" ||
+            !scripts[manifest.portless.script]) {
+            return yield* new InvalidComposition({
+                message: `Invalid Portless development command: ${file.target}`,
+            });
+        }
+        const [, application] = file.target.split("/");
+        const appPort = port === undefined
+            ? undefined
+            : new Map([
+                ["web", port],
+                ["api", port + 1],
+                ["admin", port + 2],
+            ]).get(application ?? "");
+        const scopedName = `${application}.${namespace}`;
+        if (manifest.portless.name !== undefined) {
+            const hostname = `${manifest.portless.name}.localhost`;
+            if (hosts.has(hostname)) {
+                return yield* new InvalidComposition({
+                    message: `Duplicate Portless hostname: ${hostname}`,
+                });
+            }
+            hosts.set(hostname, `${scopedName}.localhost`);
+        }
+        output.push({
+            ...file,
+            content: new TextEncoder().encode(`${yield* Schema.encodeEffect(Manifest)({ ...manifest, portless: { ...manifest.portless, appPort, name: scopedName } })}\n`),
+        });
+    }
+    if (hosts.size === 0) {
+        return output;
+    }
+    const escaped = [...hosts.keys()].map((hostname) => hostname.replaceAll(/[.*+?^${}()|[\]\\]/gu, "\\$&"));
+    const pattern = new RegExp(`(?<![\\w.-])(?:${escaped.join("|")})(?![\\w.-])`, "gu");
+    return output.map((file) => {
+        if (opaqueTargets.has(file.target) ||
+            !isUtf8(file.content) ||
+            file.content.includes(0)) {
+            return file;
+        }
+        const text = new TextDecoder().decode(file.content);
+        const updated = text.replaceAll(pattern, (hostname) => hosts.get(hostname) ?? hostname);
+        return updated === text
+            ? file
+            : { ...file, content: new TextEncoder().encode(updated) };
+    });
+});

package/dist/index.d.ts

@@ -1,7 +1,5 @@
-import { useComposition } from "./composition/use.js";
-type CliDependencies = {
-    useComposition?: typeof useComposition;
-};
-export declare function runCli(argv?: string[], dependencies?: CliDependencies): Promise<void>;
-export type { CreateOptions, ResolvedCreateOptions, ScaffoldResult, StarterDefinition, } from "./types.js";
+import { Effect, FileSystem, Path, Schema } from "effect";
+export declare const cliProgram: (argv?: readonly string[]) => Effect.Effect<void, import("./errors.ts").DestinationNotEmpty | import("./errors.ts").MaterializationFailed | import("./errors.ts").EnvironmentInitializationFailed | import("./errors.ts").WorkspaceBusy | import("./errors.ts").WorkspaceLockAuthorizationRequired | import("./errors.ts").WorkspaceLockChanged | import("./errors.ts").WorkspaceConflict | import("./errors.ts").WorkspaceRecoveryRequired | import("./errors.ts").WorkspaceStateInvalid | import("./errors.ts").WorkspaceNotCurrent | import("./errors.ts").WorkspaceBatchFailed | import("./errors.ts").SnapshotUnavailable | import("./errors.ts").WorkspaceUninitialized | import("./errors.ts").SnapshotFailed | import("./errors.ts").DependencyInstallationFailed | import("effect/PlatformError").BadArgument | import("./addition.ts").AdditionChanged | import("./addition.ts").AdditionConflict | import("./addition.ts").AdditionFailed | import("./application-git.ts").ApplicationGitFailed | import("./source-changes.ts").SourceWatchFailure | (import("./errors.ts").IncompatibleSelection | import("./errors.ts").InvalidComposition | import("./errors.ts").SourceChanged | import("./errors.ts").SourceAcquisitionFailed | import("./errors.ts").SourceStorageRetained | import("./errors.ts").RegistryFailure | import("./errors.ts").StagingRetained | import("./errors.ts").RegistryWorkerFailure | Schema.SchemaError | import("effect/PlatformError").PlatformError) | import("effect/unstable/cli/CliError").CliError, FileSystem.FileSystem | Path.Path | import("effect/unstable/process/ChildProcessSpawner").ChildProcessSpawner | import("./workspaces.ts").Workspaces | import("effect/Terminal").Terminal | import("effect/Stdio").Stdio>;
+export declare const runCli: (argv?: readonly string[]) => Promise<void>;
+export type { CreateOptions, ResolvedCreateOptions, ScaffoldResult, StarterDefinition, } from "./types.ts";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAsBtD,KAAK,eAAe,GAAG;IACrB,cAAc,CAAC,EAAE,OAAO,cAAc,CAAC;CACxC,CAAC;AA0BF,wBAAsB,MAAM,CAC1B,IAAI,WAAe,EACnB,YAAY,GAAE,eAAoB,GACjC,OAAO,CAAC,IAAI,CAAC,CA4Ff;AACD,YAAY,EACV,aAAa,EACb,qBAAqB,EACrB,cAAc,EACd,iBAAiB,GAClB,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAK1D,eAAO,MAAM,UAAU,GAAI,OAAM,SAAS,MAAM,EAAiB,kpDAiB7D,CAAC;AAIL,eAAO,MAAM,MAAM,GACjB,OAAM,SAAS,MAAM,EAAiB,KACrC,OAAO,CAAC,IAAI,CAEd,CAAC;AAEF,YAAY,EACV,aAAa,EACb,qBAAqB,EACrB,cAAc,EACd,iBAAiB,GAClB,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -1,89 +1,17 @@
-import { Command } from "commander";
-import { addRegistryItem } from "./composition/add.js";
-import { useComposition } from "./composition/use.js";
-import { CLI_NAME, DEFAULT_REPO_URL } from "./constants.js";
-import { promptForTargetDirectory } from "./prompts.js";
-import { scaffoldProject } from "./scaffold.js";
-import { CLI_VERSION } from "./version.js";
-function buildCreateOptions(targetDir, rawOptions) {
-    return {
-        addOns: rawOptions.addOn,
-        auth: rawOptions.auth,
-        cms: rawOptions.cms,
-        commerce: rawOptions.commerce,
-        commit: rawOptions.commit ?? true,
-        preset: rawOptions.preset,
-        ref: rawOptions.ref,
-        repoUrl: rawOptions.repoUrl ?? DEFAULT_REPO_URL,
-        skipGit: rawOptions.skipGit ?? false,
-        targetDir,
-        verbose: rawOptions.verbose ?? false,
-        yes: rawOptions.yes ?? false,
-    };
-}
-export async function runCli(argv = process.argv, dependencies = {}) {
-    const program = new Command().enablePositionalOptions();
-    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("--auth <provider>", "Select the Auth provider")
-        .option("--cms <provider>", "Select the CMS provider")
-        .option("--commerce <provider>", "Select the Commerce provider")
-        .option("--add-on <selection>", "Select an Add-on (repeatable)", (value, previous) => [
-        ...(previous ?? []),
-        value,
-    ])
-        .option("--preset <selection>", "Use a portable next-hydra preset")
-        .option("--verbose", "Print git command output")
-        .version(CLI_VERSION)
-        .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));
-    });
-    program
-        .command("use")
-        .description("Change or check the maintainer workspace composition")
-        .option("--auth <provider>", "Select the Auth provider")
-        .option("--cms <provider>", "Select the CMS provider")
-        .option("--commerce <provider>", "Select the Commerce provider")
-        .option("--add-on <selection>", "Select an Add-on (repeatable)", (value, previous) => [
-        ...(previous ?? []),
-        value,
-    ])
-        .option("--preset <selection>", "Use a portable next-hydra preset")
-        .option("--check", "Check for composition drift without writing")
-        .option("--dry-run", "Preview and validate changes without writing")
-        .option("-y, --yes", "Apply changes without confirmation")
-        .option("--verbose", "Print package-manager output")
-        .action(async (rawOptions) => {
-        await (dependencies.useComposition ?? useComposition)({
-            ...rawOptions,
-            addOns: rawOptions.addOn,
-        });
-    });
-    program
-        .command("add")
-        .description("Add a registry item to a customer-owned workspace")
-        .argument("<item-or-url>", "Registry item, URL, or local item JSON")
-        .option("-y, --yes", "Skip confirmation prompts")
-        .option("-o, --overwrite", "Overwrite changed files and package entries")
-        .action(async (reference, rawOptions) => {
-        await addRegistryItem(reference, {
-            overwrite: rawOptions.overwrite,
-            yes: rawOptions.yes,
-        });
-    });
-    await program.parseAsync(argv);
-}
+import { Effect, FileSystem, Path, Schema } from "effect";
+import { runCommand } from "./commands.js";
+import { runtime } from "./runtime.js";
+export const cliProgram = (argv = process.argv) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const packagePath = yield* path.fromFileUrl(new URL("../package.json", import.meta.url));
+    const metadata = yield* fs
+        .readFileString(packagePath)
+        .pipe(Effect.flatMap(Schema.decodeEffect(Schema.fromJsonString(Schema.Struct({ version: Schema.String })))));
+    yield* runCommand(process.cwd(), argv.slice(2), metadata.version);
+});
+// The Promise boundary belongs to callers embedding the CLI. All commands share
+// the same Effect program and Layer as the executable.
+export const runCli = async (argv = process.argv) => {
+    await Effect.runPromise(cliProgram(argv).pipe(Effect.provide(runtime)));
+};

package/dist/initialization.d.ts

@@ -0,0 +1,14 @@
+import { Effect, FileSystem, Path } from "effect";
+import { DestinationNotEmpty, InvalidComposition, SourceChanged } from "./errors.ts";
+type WorkspaceSettingKind = "definition" | "readme" | "ignore" | "deployment";
+export declare function workspaceSetting(target: string): WorkspaceSettingKind | undefined;
+export declare const validatePreservedFiles: (targets: readonly string[]) => Effect.Effect<undefined, InvalidComposition, never>;
+export declare const namedInitializationFiles: (files: readonly (import("./model.ts").PreparedFile & {
+    readonly origin: import("./model.ts").FileOrigin;
+})[], preserved: ReadonlySet<string>, preserve?: readonly string[] | undefined) => Effect.Effect<(import("./model.ts").PreparedFile & {
+    readonly origin: import("./model.ts").FileOrigin;
+})[], InvalidComposition, never>;
+export declare const listUnregisteredFiles: (destination: string, owned: ReadonlySet<string>) => Effect.Effect<string[], DestinationNotEmpty | import("effect/PlatformError").PlatformError, FileSystem.FileSystem | Path.Path>;
+export declare const inspectInitialization: (destination: string, definition?: string | undefined) => Effect.Effect<Set<string>, SourceChanged | DestinationNotEmpty | import("effect/PlatformError").PlatformError, FileSystem.FileSystem | Path.Path>;
+export {};
+//# sourceMappingURL=initialization.d.ts.map

package/dist/initialization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initialization.d.ts","sourceRoot":"","sources":["../src/initialization.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAElD,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,aAAa,EACd,MAAM,aAAa,CAAC;AAKrB,KAAK,oBAAoB,GAAG,YAAY,GAAG,QAAQ,GAAG,QAAQ,GAAG,YAAY,CAAC;AAsB9E,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,GACb,oBAAoB,GAAG,SAAS,CAgBlC;AAED,eAAO,MAAM,sBAAsB,qFAiCjC,CAAC;AA+BH,eAAO,MAAM,wBAAwB;;;;gCA2DnC,CAAC;AAEH,eAAO,MAAM,qBAAqB,qLA6DhC,CAAC;AA+BH,eAAO,MAAM,qBAAqB,6MAmDhC,CAAC"}