create-next-hydra 0.3.0 → 0.4.2

package/dist/addition.js

@@ -0,0 +1,422 @@
+import { createHash } from "node:crypto";
+import { Array as EffectArray, Effect, FileSystem, Order, Path, Redacted, Schema, } from "effect";
+import { InvalidComposition } from "./errors.js";
+import { relativeFile, writeFile } from "./files.js";
+import { ManifestJson, registryDependencies } from "./packages.js";
+import { acquireRegistry, registryInstructions } from "./registry.js";
+import { providerAliases, registryIndex } from "./selection.js";
+import { Shadcn } from "./shadcn.js";
+import { withRegistryInstallation } from "./staging.js";
+import { WorkspaceDependencies } from "./workspace-dependencies.js";
+export class AdditionChanged extends Schema.TaggedError()("AdditionChanged", {}) {
+    message = "The registry or project changed after inspection. Inspect the addition again before applying it. No installation was started.";
+}
+export class AdditionConflict extends Schema.TaggedError()("AdditionConflict", { paths: Schema.Array(Schema.String) }) {
+    get message() {
+        return `Adding this item would replace local work: ${this.paths.join(", ")}. Explicit replacement permission is required.`;
+    }
+}
+export class AdditionFailed extends Schema.TaggedError()("AdditionFailed", {
+    diagnostic: Schema.Redacted(Schema.String),
+    directory: Schema.String,
+    phase: Schema.Literals(["registry", "packages"]),
+}) {
+    get message() {
+        return `Addition failed during ${this.phase} installation in ${this.directory}. Project changes may remain; inspect them before retrying. No rollback was attempted.`;
+    }
+}
+const json = Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown));
+const digest = (bytes) => createHash("sha256").update(bytes).digest("hex");
+function fileStatus(actual, expected) {
+    if (actual === null) {
+        return "create";
+    }
+    return actual === digest(expected) ? "identical" : "changed";
+}
+// Published selection identities are also recognizable in projects that do not
+// keep a composition receipt. Custom providers are described by the acquired graph.
+const knownProviders = new Map([
+    [
+        "next-hydra/search/algolia",
+        { alias: "@repo/search-provider", package: "@repo/search-algolia" },
+    ],
+    [
+        "next-hydra/auth/clerk",
+        { alias: "@repo/auth", package: "@repo/auth-clerk" },
+    ],
+    [
+        "next-hydra/auth/workos",
+        { alias: "@repo/auth", package: "@repo/auth-workos" },
+    ],
+    [
+        "next-hydra/cms/contentstack",
+        { alias: "@repo/cms", package: "@repo/cms-contentstack" },
+    ],
+    [
+        "next-hydra/cms/drupal",
+        { alias: "@repo/cms", package: "@repo/cms-drupal" },
+    ],
+    [
+        "next-hydra/commerce/commercetools",
+        {
+            alias: "@repo/commerce-provider",
+            package: "@repo/commerce-commercetools",
+        },
+    ],
+]);
+const validateAddition = Effect.fn("ExistingWorkspace.validateAddition")(function* (index, reference) {
+    if (index.metadataByName.get(index.references.get(reference) ?? "")?.kind ===
+        "provider") {
+        return yield* new InvalidComposition({
+            message: "Add does not switch providers. Select providers when composing an application.",
+        });
+    }
+    for (const item of index.items.values()) {
+        const metadata = index.metadataByName.get(item.name);
+        if (item.meta?.composition !== undefined ||
+            metadata?.kind === "preset" ||
+            metadata?.kind === "recipe" ||
+            (metadata?.conditionalDependencies?.length ?? 0) > 0 ||
+            (metadata?.assets?.length ?? 0) > 0 ||
+            (metadata?.pnpmPatches?.length ?? 0) > 0) {
+            return yield* new InvalidComposition({
+                message: "Add installs files into an existing project; select templates, presets and composition recipes when composing the application.",
+            });
+        }
+        if (item.css ||
+            item.cssVars ||
+            item.tailwind ||
+            ("fonts" in item &&
+                Array.isArray(item.fonts) &&
+                item.fonts.length > 0) ||
+            "config" in item) {
+            return yield* new InvalidComposition({
+                message: "This registry item needs a configured package-local ShadCN installation; root addition cannot apply its configuration changes.",
+            });
+        }
+    }
+});
+function packageStatus(actual, expected) {
+    if (actual === undefined) {
+        return "create";
+    }
+    return expected === undefined || actual === expected
+        ? "identical"
+        : "changed";
+}
+const installedRequirements = Effect.fn("ExistingWorkspace.installedRequirements")(function* (index, manifest) {
+    const selections = new Map([...index.metadataByName.values()].map((metadata) => [
+        metadata.id,
+        metadata,
+    ]));
+    const assumptions = [];
+    const packages = [];
+    const matches = (id) => {
+        const selection = selections.get(id);
+        if (selection?.kind !== "provider" ||
+            !selection.slot ||
+            !selection.binding) {
+            const known = knownProviders.get(id);
+            if (!known) {
+                return undefined;
+            }
+            const actual = manifest.dependencies?.[known.alias];
+            return (actual === known.package ||
+                actual?.startsWith(`workspace:${known.package}@`) === true ||
+                actual?.startsWith(`npm:${known.package}@`) === true);
+        }
+        return (manifest.dependencies?.[providerAliases[selection.slot]] ===
+            selection.binding.specifier);
+    };
+    for (const metadata of selections.values()) {
+        for (const slot of ["auth", "cms", "commerce", "search"]) {
+            const requirement = metadata.providerSlots?.[slot];
+            const present = manifest.dependencies?.[providerAliases[slot]] !== undefined;
+            if ((requirement === "required" && !present) ||
+                (requirement === "forbidden" && present)) {
+                return yield* new InvalidComposition({
+                    message: `${metadata.id} ${requirement === "required" ? "requires" : "forbids"} an installed ${slot} provider.`,
+                });
+            }
+        }
+        if (metadata.kind === "provider" && matches(metadata.id) !== true) {
+            return yield* new InvalidComposition({
+                message: "The requested registry graph requires a different installed provider. Add cannot switch providers.",
+            });
+        }
+        for (const required of metadata.compatibility?.requires ?? []) {
+            const match = matches(required);
+            if (match === false) {
+                return yield* new InvalidComposition({
+                    message: "An add-on requires a different installed provider.",
+                });
+            }
+            if (match === undefined && selections.get(required)?.kind !== "add-on") {
+                assumptions.push("A registry requirement cannot be verified: this project has no authoritative selection record.");
+            }
+        }
+        for (const conflict of metadata.compatibility?.conflicts ?? []) {
+            const match = matches(conflict);
+            if (match === true || selections.get(conflict)?.kind === "add-on") {
+                return yield* new InvalidComposition({
+                    message: "The requested registry graph conflicts with an installed provider or selected add-on.",
+                });
+            }
+            if (match === undefined) {
+                assumptions.push("A registry conflict cannot be ruled out: this project has no authoritative selection record.");
+            }
+        }
+        packages.push(...(metadata.packages ?? []));
+        for (const requirement of metadata.providerDependencies ?? []) {
+            const name = providerAliases[requirement.slot];
+            const specifier = manifest.dependencies?.[name];
+            if (!specifier) {
+                return yield* new InvalidComposition({
+                    message: `The installed application has no ${requirement.slot} provider binding.`,
+                });
+            }
+            packages.push({
+                cwd: requirement.cwd,
+                name,
+                section: requirement.section,
+                specifier,
+            });
+        }
+    }
+    return { assumptions, packages };
+});
+export const existingWorkspace = Effect.fn("Workspaces.existing")(function* (root) {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const shadcn = yield* Shadcn;
+    const dependencies = yield* WorkspaceDependencies;
+    const directory = path.resolve(root);
+    const observe = (target) => fs.readFile(path.join(directory, target)).pipe(Effect.map(digest), Effect.catchIf((error) => error.reason._tag === "NotFound", () => Effect.succeed(null)));
+    const inspect = Effect.fn("ExistingWorkspace.inspect")(function* (reference) {
+        const graph = yield* acquireRegistry(directory, { reference }).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path), Effect.provideService(Shadcn, shadcn));
+        const index = yield* registryIndex(graph.registry, graph.references);
+        yield* validateAddition(index, reference);
+        // A project manifest is required, but its contents never appear in inspection.
+        yield* fs.access(path.join(directory, "package.json"));
+        const web = yield* fs
+            .readFileString(path.join(directory, "apps/web/package.json"))
+            .pipe(Effect.flatMap(Schema.decodeEffect(ManifestJson)), Effect.catchIf((error) => error._tag === "PlatformError" && error.reason._tag === "NotFound", () => Effect.succeed({})));
+        const installed = yield* installedRequirements(index, web);
+        const environment = EffectArray.sort(new Set(graph.registry.items.flatMap((item) => Object.keys(item.envVars ?? {}))), Order.String);
+        const facts = new Map();
+        const files = [];
+        const packages = [];
+        const requirements = new Map();
+        const manifests = new Map();
+        for (const requirement of installed.packages) {
+            const target = requirement.cwd === "."
+                ? "package.json"
+                : `${yield* relativeFile(requirement.cwd)}/package.json`;
+            const key = `${target}:${requirement.section}:${requirement.name}`;
+            const existing = requirements.get(key);
+            if (existing !== undefined && existing !== requirement.specifier) {
+                return yield* new InvalidComposition({
+                    message: `Conflicting package requirements for ${key}`,
+                });
+            }
+            if (existing === undefined) {
+                packages.push({ ...requirement, target });
+            }
+            requirements.set(key, requirement.specifier);
+            facts.set(target, yield* observe(target));
+        }
+        for (const item of graph.registry.items) {
+            for (const file of item.files ?? []) {
+                if (!file.target?.startsWith("~/") ||
+                    file.content === undefined ||
+                    !["registry:file", "registry:item"].includes(file.type)) {
+                    return yield* new InvalidComposition({
+                        message: "Add requires hydrated exact-copy files with explicit workspace-root targets.",
+                    });
+                }
+                const target = yield* relativeFile(file.target);
+                if (files.some((existing) => existing.target === target)) {
+                    return yield* new InvalidComposition({
+                        message: `Multiple registry files claim ${target}`,
+                    });
+                }
+                const current = yield* observe(target);
+                facts.set(target, current);
+                files.push({ status: fileStatus(current, file.content), target });
+                if (target === "package.json" || target.endsWith("/package.json")) {
+                    manifests.set(target, file.content);
+                }
+            }
+        }
+        const packageChanges = [];
+        const rootRequirements = yield* registryDependencies(graph.registry.items);
+        for (const requirement of packages) {
+            const native = rootRequirements.find((entry) => entry.name === requirement.name);
+            if (requirement.target === "package.json" &&
+                native?.specifier !== undefined &&
+                native.specifier !== requirement.specifier) {
+                return yield* new InvalidComposition({
+                    message: `Conflicting root dependency requirements for ${requirement.name}`,
+                });
+            }
+        }
+        const rootManifest = yield* Schema.decodeEffect(ManifestJson)(manifests.get("package.json") ??
+            (yield* fs.readFileString(path.join(directory, "package.json"))));
+        for (const requirement of rootRequirements) {
+            const actual = rootManifest.dependencies?.[requirement.name] ??
+                rootManifest.devDependencies?.[requirement.name] ??
+                rootManifest.optionalDependencies?.[requirement.name] ??
+                rootManifest.peerDependencies?.[requirement.name];
+            packageChanges.push({
+                name: requirement.name,
+                section: requirement.section,
+                status: packageStatus(actual, requirement.specifier),
+                target: "package.json",
+            });
+        }
+        for (const requirement of packages) {
+            const manifest = yield* Schema.decodeEffect(ManifestJson)(manifests.get(requirement.target) ??
+                (yield* fs.readFileString(path.join(directory, requirement.target))));
+            const actual = manifest[requirement.section]?.[requirement.name];
+            packageChanges.push({
+                name: requirement.name,
+                section: requirement.section,
+                status: packageStatus(actual, requirement.specifier),
+                target: requirement.target,
+            });
+        }
+        for (const target of [
+            "package.json",
+            "components.json",
+            "apps/web/package.json",
+            // These are the native adapter's possible environment targets. Bind their
+            // presence and content to inspection without putting values in the report.
+            ...(environment.length
+                ? [".env.local", ".env", ".env.development.local", ".env.development"]
+                : []),
+        ]) {
+            facts.set(target, yield* observe(target));
+        }
+        const precondition = digest(yield* json({
+            artifacts: graph.registry.items,
+            directory,
+            facts: [...facts],
+            reference,
+        }));
+        return {
+            facts,
+            graph,
+            inspection: {
+                assumptions: installed.assumptions,
+                environment,
+                files,
+                packages: packageChanges,
+                precondition,
+            },
+            needsInstall: packages.length > 0 ||
+                rootRequirements.length > 0 ||
+                manifests.size > 0 ||
+                files.some(({ target }) => [
+                    "pnpm-workspace.yaml",
+                    "pnpm-lock.yaml",
+                    ".npmrc",
+                    ".pnpmfile.cjs",
+                ].includes(target)),
+            packages,
+        };
+    });
+    const inspectAdd = Effect.fn("ExistingWorkspace.inspectAdd")(function* (request) {
+        return (yield* inspect(request.reference)).inspection;
+    });
+    const add = Effect.fn("ExistingWorkspace.add")(function* (request) {
+        const checked = yield* inspect(request.reference);
+        if (request.expected !== undefined &&
+            request.expected !== checked.inspection.precondition) {
+            return yield* new AdditionChanged();
+        }
+        const conflicts = [
+            ...checked.inspection.files,
+            ...checked.inspection.packages,
+        ]
+            .filter((file) => file.status === "changed")
+            .map((file) => file.target);
+        if (!request.overwrite && conflicts.length) {
+            return yield* new AdditionConflict({ paths: conflicts });
+        }
+        yield* withRegistryInstallation(directory, (installation) => Effect.gen(function* () {
+            const artifacts = new Map(checked.graph.registry.items.map((item, ordinal) => [
+                item.name,
+                path.join(installation.registry, `${ordinal}.json`),
+            ]));
+            for (const [ordinal, item] of checked.graph.registry.items.entries()) {
+                const registryReferences = [];
+                for (const reference of item.registryDependencies ?? []) {
+                    const dependency = artifacts.get(checked.graph.references.get(reference) ?? reference);
+                    if (!dependency) {
+                        return yield* new InvalidComposition({
+                            message: "Registry dependency was not acquired.",
+                        });
+                    }
+                    registryReferences.push(dependency);
+                }
+                yield* writeFile(installation.registry, {
+                    content: new TextEncoder().encode(yield* json({
+                        ...item,
+                        docs: undefined,
+                        registryDependencies: registryReferences,
+                    })),
+                    mode: 0o600,
+                    target: `${ordinal}.json`,
+                });
+            }
+            for (const [target, value] of checked.facts) {
+                if ((yield* observe(target)) !== value) {
+                    return yield* new AdditionChanged();
+                }
+            }
+            yield* shadcn
+                .install(installation, [...artifacts.values()], request.overwrite)
+                .pipe(Effect.mapError((error) => new AdditionFailed({
+                diagnostic: Redacted.make(String(error)),
+                directory,
+                phase: "registry",
+            })));
+        })).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path));
+        yield* Effect.gen(function* () {
+            // Read after native installation so its manifest edits are retained.
+            for (const requirement of checked.packages) {
+                const target = path.join(directory, requirement.target);
+                const manifest = yield* Schema.decodeEffect(ManifestJson)(yield* fs.readFileString(target));
+                const actual = manifest[requirement.section]?.[requirement.name];
+                if (actual !== undefined &&
+                    actual !== requirement.specifier &&
+                    !request.overwrite) {
+                    return yield* new AdditionConflict({ paths: [requirement.target] });
+                }
+                const updated = {
+                    ...manifest,
+                    [requirement.section]: {
+                        ...manifest[requirement.section],
+                        [requirement.name]: requirement.specifier,
+                    },
+                };
+                yield* fs
+                    .writeFileString(target, `${yield* Schema.encodeEffect(ManifestJson)(updated)}\n`)
+                    .pipe(Effect.uninterruptible);
+            }
+        }).pipe(Effect.mapError((error) => new AdditionFailed({
+            diagnostic: Redacted.make(String(error)),
+            directory,
+            phase: "packages",
+        })));
+        if (checked.needsInstall) {
+            yield* dependencies.install(directory);
+        }
+        return {
+            directory,
+            files: checked.inspection.files,
+            instructions: registryInstructions(checked.graph.registry.items),
+        };
+    });
+    return { add, inspectAdd };
+});

package/dist/application-git.d.ts

@@ -0,0 +1,20 @@
+import { Effect, Schema } from "effect";
+import { ChildProcessSpawner } from "effect/unstable/process";
+declare const ApplicationGitFailed_base: Schema.Class<ApplicationGitFailed, Schema.TaggedStruct<"ApplicationGitFailed", {
+    readonly diagnostic: Schema.Redacted<Schema.Unknown>;
+    readonly directory: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ApplicationGitFailed extends ApplicationGitFailed_base {
+    get message(): string;
+}
+export declare const initializeApplicationGit: (directory: string, commit: boolean) => Effect.Effect<{
+    committed: boolean;
+    initialized: boolean;
+    warning?: undefined;
+} | {
+    committed: false;
+    initialized: boolean;
+    warning: string;
+}, ApplicationGitFailed, ChildProcessSpawner.ChildProcessSpawner>;
+export {};
+//# sourceMappingURL=application-git.d.ts.map

package/dist/application-git.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"application-git.d.ts","sourceRoot":"","sources":["../src/application-git.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAY,MAAM,EAAE,MAAM,QAAQ,CAAC;AAClD,OAAO,EAAgB,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;;;;;AAI5E,qBAAa,oBAAqB,SAAQ,yBAGzC;IACC,IAAI,OAAO,WAEV;CACF;AAED,eAAO,MAAM,wBAAwB;;;;;;;;iEAuEnC,CAAC"}

package/dist/application-git.js

@@ -0,0 +1,57 @@
+import { Effect, Redacted, Schema } from "effect";
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+import { confirmStopped, groupExists } from "./process-group.js";
+export class ApplicationGitFailed extends Schema.TaggedError()("ApplicationGitFailed", { diagnostic: Schema.Redacted(Schema.Unknown), directory: Schema.String }) {
+    get message() {
+        return `Git initialization failed in ${this.directory}. The composed application remains available for inspection.`;
+    }
+}
+export const initializeApplicationGit = Effect.fn("Workspaces.initializeApplicationGit")(function* (directory, commit) {
+    const processes = yield* ChildProcessSpawner.ChildProcessSpawner;
+    const git = (args) => Effect.scoped(Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+        const handle = yield* processes.spawn(ChildProcess.make("git", args, {
+            cwd: directory,
+            forceKillAfter: "100 millis",
+            stderr: "ignore",
+            stdin: "ignore",
+            stdout: "ignore",
+        }));
+        return yield* restore(Effect.gen(function* () {
+            const code = yield* handle.exitCode;
+            if (yield* groupExists(handle.pid)) {
+                return yield* new ApplicationGitFailed({
+                    diagnostic: Redacted.make("Git left an active process"),
+                    directory,
+                });
+            }
+            return code;
+        })).pipe(Effect.onExit(() => confirmStopped(handle).pipe(Effect.onExit(() => handle.unref.pipe(Effect.asVoid)))));
+    }))).pipe(Effect.mapError((error) => new ApplicationGitFailed({
+        diagnostic: Redacted.make(error),
+        directory,
+    })));
+    if ((yield* git(["init"])) !== 0) {
+        return yield* new ApplicationGitFailed({
+            diagnostic: Redacted.make("git init failed"),
+            directory,
+        });
+    }
+    if (!commit) {
+        return { committed: false, initialized: true };
+    }
+    if ((yield* git(["add", "-A"])) !== 0) {
+        return yield* new ApplicationGitFailed({
+            diagnostic: Redacted.make("git add failed"),
+            directory,
+        });
+    }
+    const committed = (yield* git(["commit", "-m", "Initial commit"])) === 0;
+    if (committed) {
+        return { committed, initialized: true };
+    }
+    return {
+        committed,
+        initialized: true,
+        warning: "Git was initialized, but the initial commit failed. Check your Git identity and hooks, then commit from the project directory.",
+    };
+});

package/dist/baseline.d.ts

@@ -0,0 +1,22 @@
+import { Effect, Schema } from "effect";
+import { InvalidComposition } from "./errors.ts";
+export declare const applicationIgnoreRules = "node_modules/\n.next/\n.turbo/\n.env\n.env.*\n!.env.example\n*.tsbuildinfo\n";
+export declare function normalizeApplicationName(name: string): string;
+export declare const yamlDocument: <A>(bytes: Uint8Array<ArrayBufferLike>, target: string, schema: Schema.Decoder<A, never>) => Effect.Effect<{
+    data: A;
+    document: import("yaml").Document.Parsed<import("yaml").Alias.Parsed, true> | import("yaml").Document.Parsed<import("yaml").Scalar.Parsed, true> | import("yaml").Document.Parsed<import("yaml").YAMLMap.Parsed<import("yaml").ParsedNode, import("yaml").ParsedNode | null>, true> | import("yaml").Document.Parsed<import("yaml").YAMLSeq.Parsed<import("yaml").ParsedNode>, true>;
+}, InvalidComposition | Schema.SchemaError, never>;
+export declare const applicationWorkspace: (settings: {
+    data: {
+        readonly packages: readonly string[];
+    };
+    document: import("yaml").Document.Parsed<import("yaml").Alias.Parsed, true> | import("yaml").Document.Parsed<import("yaml").Scalar.Parsed, true> | import("yaml").Document.Parsed<import("yaml").YAMLMap.Parsed<import("yaml").ParsedNode, import("yaml").ParsedNode | null>, true> | import("yaml").Document.Parsed<import("yaml").YAMLSeq.Parsed<import("yaml").ParsedNode>, true>;
+}, lockSource: Uint8Array<ArrayBufferLike>, targets: ReadonlySet<string>, patches: ReadonlyMap<string, string>) => Effect.Effect<Map<string, NodeJS.NonSharedUint8Array>, InvalidComposition | Schema.SchemaError, never>;
+export declare const readWorkspaceSettings: (source: Uint8Array) => Effect.Effect<{
+    data: {
+        readonly packages: readonly string[];
+    };
+    document: import("yaml").Document.Parsed<import("yaml").Alias.Parsed, true> | import("yaml").Document.Parsed<import("yaml").Scalar.Parsed, true> | import("yaml").Document.Parsed<import("yaml").YAMLMap.Parsed<import("yaml").ParsedNode, import("yaml").ParsedNode | null>, true> | import("yaml").Document.Parsed<import("yaml").YAMLSeq.Parsed<import("yaml").ParsedNode>, true>;
+}, InvalidComposition | Schema.SchemaError, never>;
+export declare const applicationManifest: (source: Uint8Array<ArrayBufferLike>, name: string, browserTests: boolean) => Effect.Effect<NodeJS.NonSharedUint8Array, InvalidComposition | Schema.SchemaError, never>;
+//# sourceMappingURL=baseline.d.ts.map

package/dist/baseline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseline.d.ts","sourceRoot":"","sources":["../src/baseline.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGxC,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAGjD,eAAO,MAAM,sBAAsB,iFAOlC,CAAC;AAEF,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAW7D;AAsBD,eAAO,MAAM,YAAY,GAAoD,CAAC;;;kDAoB5E,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;yNAqC/B,CAAC;AAEH,eAAO,MAAM,qBAAqB,GAAI,QAAQ,UAAU;;;;;kDACQ,CAAC;AAEjE,eAAO,MAAM,mBAAmB,yKA6B/B,CAAC"}

package/dist/baseline.js

@@ -0,0 +1,90 @@
+import { Effect, Schema } from "effect";
+import { parseDocument } from "yaml";
+import { InvalidComposition } from "./errors.js";
+import { applicationPackagePatterns } from "./package-catalog.js";
+export const applicationIgnoreRules = `node_modules/
+.next/
+.turbo/
+.env
+.env.*
+!.env.example
+*.tsbuildinfo
+`;
+export function normalizeApplicationName(name) {
+    return (name
+        .trim()
+        .toLowerCase()
+        .replaceAll(/[^a-z0-9._-]+/gu, "-")
+        .replaceAll(/-+/gu, "-")
+        .replace(/^[._-]+/u, "")
+        .slice(0, 214)
+        .replace(/[._-]+$/u, "") || "application");
+}
+const RootManifest = Schema.fromJsonString(Schema.Struct({
+    devDependencies: Schema.Record(Schema.String, Schema.String),
+    engines: Schema.optionalKey(Schema.Record(Schema.String, Schema.String)),
+    packageManager: Schema.optionalKey(Schema.String),
+}));
+const encodeJson = Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown, { space: 2 }));
+const WorkspaceSettings = Schema.Struct({
+    packages: Schema.Array(Schema.String),
+});
+const Lockfile = Schema.Struct({
+    importers: Schema.Record(Schema.String, Schema.Unknown),
+    patchedDependencies: Schema.optionalKey(Schema.Record(Schema.String, Schema.Unknown)),
+});
+export const yamlDocument = Effect.fn("Composition.yamlDocument")(function* (bytes, target, schema) {
+    const document = yield* Effect.try({
+        catch: () => new InvalidComposition({ message: `Invalid YAML: ${target}` }),
+        try: () => parseDocument(new TextDecoder().decode(bytes)),
+    });
+    if (document.errors.length > 0) {
+        return yield* new InvalidComposition({
+            message: `Invalid YAML: ${target}`,
+        });
+    }
+    const decode = yield* Effect.try({
+        catch: () => new InvalidComposition({ message: `Invalid YAML: ${target}` }),
+        try: () => Schema.decodeUnknownEffect(schema)(document.toJS()),
+    });
+    const data = yield* decode;
+    return { data, document };
+});
+export const applicationWorkspace = Effect.fn("Composition.applicationWorkspace")(function* (settings, lockSource, targets, patches) {
+    settings.document.set("packages", applicationPackagePatterns(settings.data.packages, targets));
+    settings.document.set("patchedDependencies", Object.fromEntries(patches));
+    const lock = yield* yamlDocument(lockSource, "pnpm-lock.yaml", Lockfile);
+    lock.document.set("importers", Object.fromEntries(Object.entries(lock.data.importers).filter(([cwd]) => targets.has(cwd === "." ? "package.json" : `${cwd}/package.json`))));
+    lock.document.set("patchedDependencies", Object.fromEntries(Object.entries(lock.data.patchedDependencies ?? {}).filter(([dependency]) => patches.has(dependency))));
+    return new Map([
+        [
+            "pnpm-workspace.yaml",
+            new TextEncoder().encode(settings.document.toString()),
+        ],
+        ["pnpm-lock.yaml", new TextEncoder().encode(lock.document.toString())],
+    ]);
+});
+export const readWorkspaceSettings = (source) => yamlDocument(source, "pnpm-workspace.yaml", WorkspaceSettings);
+export const applicationManifest = Effect.fn("Composition.applicationManifest")(function* (source, name, browserTests) {
+    const manifest = yield* Schema.decodeEffect(RootManifest)(new TextDecoder().decode(source));
+    if (!manifest.devDependencies.portless) {
+        return yield* new InvalidComposition({
+            message: "The source workspace must declare Portless in devDependencies",
+        });
+    }
+    const devDependencies = {
+        "@typescript/native": manifest.devDependencies["@typescript/native"],
+        portless: manifest.devDependencies.portless,
+        turbo: manifest.devDependencies.turbo,
+        typescript: "catalog:",
+    };
+    const scripts = {
+        build: "turbo run build",
+        dev: "turbo run dev",
+        test: "turbo run test",
+        "test:e2e": browserTests ? "turbo run e2e" : undefined,
+        "test:e2e:list": browserTests ? "turbo run e2e:list" : undefined,
+        typecheck: "turbo run typecheck",
+    };
+    return new TextEncoder().encode(`${yield* encodeJson({ devDependencies, engines: manifest.engines, name, packageManager: manifest.packageManager, private: true, scripts })}\n`);
+});

package/dist/cli.js

@@ -1,19 +1,6 @@
 #!/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();
+import { NodeRuntime } from "@effect/platform-node";
+import { Effect } from "effect";
+import { cliProgram } from "./index.js";
+import { runtime } from "./runtime.js";
+NodeRuntime.runMain(cliProgram().pipe(Effect.provide(runtime)));