@maple-dev/changesets 0.0.0-stage → 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,255 @@
+import { Context, Effect, FileSystem, Layer, Option, Path, Result, Schema } from "effect";
+import { ChildProcessSpawner } from "effect/process";
+import { Command, Prompt } from "effect/cli";
+type BumpType = "major" | "minor" | "patch";
+type VersionType = BumpType | "none";
+interface Release {
+  readonly name: string;
+  readonly type: VersionType;
+}
+interface Changeset {
+  readonly releases: ReadonlyArray<Release>;
+  readonly summary: string;
+}
+interface NewChangeset extends Changeset {
+  readonly id: string;
+}
+interface NewChangesetWithCommit extends NewChangeset {
+  readonly commit: string | undefined;
+}
+type DependencyRanges = Readonly<Record<string, string>>;
+interface PackageJson {
+  readonly name: string;
+  readonly version?: string;
+  readonly private?: boolean;
+  readonly dependencies?: DependencyRanges;
+  readonly devDependencies?: DependencyRanges;
+  readonly peerDependencies?: DependencyRanges;
+  readonly optionalDependencies?: DependencyRanges;
+}
+interface Package {
+  readonly dir: string;
+  readonly relativeDir: string;
+  readonly packageJson: PackageJson;
+}
+interface Packages {
+  readonly rootDir: string;
+  readonly rootPackage: Package;
+  readonly packages: ReadonlyArray<Package>;
+}
+interface ComprehensiveRelease {
+  readonly name: string;
+  readonly type: VersionType;
+  readonly oldVersion: string | undefined;
+  readonly changesets: ReadonlyArray<string>;
+  readonly newVersion: string | undefined;
+}
+interface ReleasePlan {
+  readonly changesets: ReadonlyArray<NewChangeset>;
+  readonly releases: ReadonlyArray<ComprehensiveRelease>;
+}
+declare const DEPENDENCY_TYPES: readonly ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
+type DependencyType = (typeof DEPENDENCY_TYPES)[number];
+declare const ChangesetParseError_base: Schema.Class<ChangesetParseError, Schema.TaggedStruct<"@maple-dev/changesets/ChangesetParseError", {
+  readonly message: Schema.String;
+  readonly file: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A `.changeset/*.md` file that changesets itself would also reject. */
+export declare class ChangesetParseError extends ChangesetParseError_base {}
+declare const ConfigError_base: Schema.Class<ConfigError, Schema.TaggedStruct<"@maple-dev/changesets/ConfigError", {
+  readonly message: Schema.String;
+  readonly problems: Schema.$Array<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+/** `.changeset/config.json` is missing, malformed, or breaks one of the config rules. */
+export declare class ConfigError extends ConfigError_base {}
+declare const WorkspaceError_base: Schema.Class<WorkspaceError, Schema.TaggedStruct<"@maple-dev/changesets/WorkspaceError", {
+  readonly message: Schema.String;
+  readonly path: Schema.String;
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/** The workspace root or one of its package manifests could not be read. */
+export declare class WorkspaceError extends WorkspaceError_base {}
+declare const ReleasePlanError_base: Schema.Class<ReleasePlanError, Schema.TaggedStruct<"@maple-dev/changesets/ReleasePlanError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The changesets and the workspace disagree, e.g. a changeset names an unknown package. */
+export declare class ReleasePlanError extends ReleasePlanError_base {}
+declare const GitError_base: Schema.Class<GitError, Schema.TaggedStruct<"@maple-dev/changesets/GitError", {
+  readonly message: Schema.String;
+  readonly args: Schema.$Array<Schema.String>;
+  readonly stderr: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class GitError extends GitError_base {}
+declare const FormatterError_base: Schema.Class<FormatterError, Schema.TaggedStruct<"@maple-dev/changesets/FormatterError", {
+  readonly message: Schema.String;
+  readonly formatter: Schema.String;
+  readonly stderr: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class FormatterError extends FormatterError_base {}
+declare const JsonEditError_base: Schema.Class<JsonEditError, Schema.TaggedStruct<"@maple-dev/changesets/JsonEditError", {
+  readonly message: Schema.String;
+  readonly file: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class JsonEditError extends JsonEditError_base {}
+declare const ChangelogError_base: Schema.Class<ChangelogError, Schema.TaggedStruct<"@maple-dev/changesets/ChangelogError", {
+  readonly message: Schema.String;
+  readonly module: Schema.String;
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class ChangelogError extends ChangelogError_base {}
+declare const UnsupportedFeatureError_base: Schema.Class<UnsupportedFeatureError, Schema.TaggedStruct<"@maple-dev/changesets/UnsupportedFeatureError", {
+  readonly message: Schema.String;
+  readonly feature: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A changesets feature this tool deliberately does not implement (pre mode, snapshots, commit). */
+export declare class UnsupportedFeatureError extends UnsupportedFeatureError_base {}
+declare const CommandExit_base: Schema.Class<CommandExit, Schema.TaggedStruct<"@maple-dev/changesets/CommandExit", {
+  readonly message: Schema.String;
+  readonly code: Schema.Number;
+}>, import("effect/Cause").YieldableError>;
+/** An expected non-zero exit that changesets reports the same way, e.g. "No unreleased changesets found." */
+export declare class CommandExit extends CommandExit_base {}
+type ModuleReference = readonly [string, Readonly<Record<string, unknown>> | null];
+type FormatterName = "prettier" | "oxfmt" | "deno" | "dprint";
+interface Config$1 {
+  readonly baseBranch: string;
+  readonly access: "public" | "restricted";
+  readonly changedFilePatterns: ReadonlyArray<string>;
+  readonly format: "auto" | FormatterName | false;
+  readonly ignore: ReadonlyArray<string>;
+  readonly fixed: ReadonlyArray<ReadonlyArray<string>>;
+  readonly linked: ReadonlyArray<ReadonlyArray<string>>;
+  readonly updateInternalDependencies: "minor" | "patch";
+  readonly privatePackages: {
+    readonly version: boolean;
+    readonly tag: boolean;
+  };
+  readonly bumpVersionsWithWorkspaceProtocolOnly: boolean;
+  readonly snapshot: {
+    readonly useCalculatedVersion: boolean;
+    readonly prereleaseTemplate: string | undefined;
+  };
+  readonly changelog: ModuleReference | false;
+  readonly commit: ModuleReference | false;
+  readonly onlyUpdatePeerDependentsWhenOutOfRange: boolean;
+  readonly updateInternalDependents: "always" | "out-of-range";
+}
+interface FormatterApi {
+  /** The formatter `config.format` resolves to for this root, if any. */
+  readonly detect: (format: Config$1["format"], rootDir: string) => Effect.Effect<Option.Option<FormatterName>>;
+  /** Formats `files` in place; a formatter that exits non-zero fails, as in changesets. */
+  readonly format: (format: Config$1["format"], rootDir: string, files: ReadonlyArray<string>) => Effect.Effect<void, FormatterError>;
+}
+declare const Formatter_base: Context.ServiceClass<Formatter, "@maple-dev/changesets/Formatter", FormatterApi> & {
+  readonly make: Effect.Effect<FormatterApi, never, ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | Path.Path>;
+};
+declare class Formatter extends Formatter_base {
+  static readonly layer: Layer.Layer<Formatter, never, ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | Path.Path>;
+}
+interface GitResult {
+  readonly exitCode: number;
+  readonly stdout: string;
+  readonly stderr: string;
+}
+interface GitApi {
+  /** Runs `git <args>` in `cwd`; a non-zero exit is a result, not a failure. */
+  readonly run: (args: ReadonlyArray<string>, cwd: string) => Effect.Effect<GitResult, GitError>;
+  /** For each path, the commit that added it (extending a shallow clone as needed), if any. */
+  readonly commitsThatAddFiles: (paths: ReadonlyArray<string>, cwd: string) => Effect.Effect<ReadonlyArray<string | undefined>, GitError>;
+  /** Absolute paths of files changed between the merge base of `ref` and HEAD. */
+  readonly changedFilesSince: (ref: string, cwd: string) => Effect.Effect<ReadonlyArray<string>, GitError>;
+  /** Changeset files (`.changeset/*.md`, `.changeset/pre/*.md`) added or changed since `ref`. */
+  readonly changedChangesetFilesSince: (ref: string, cwd: string) => Effect.Effect<ReadonlyArray<string>, GitError>;
+}
+declare const Git_base: Context.ServiceClass<Git, "@maple-dev/changesets/Git", GitApi> & {
+  readonly make: Effect.Effect<GitApi, never, ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | Path.Path>;
+};
+declare class Git extends Git_base {
+  static readonly layer: Layer.Layer<Git, never, ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | Path.Path>;
+}
+interface Project {
+  readonly packages: Packages;
+  readonly config: Config$1;
+  readonly warnings: ReadonlyArray<string>;
+}
+declare const Changesets_base: Context.ServiceClass<Changesets, "@maple-dev/changesets/Changesets", {
+  load: (cwd: string) => Effect.Effect<{
+    packages: {
+      rootDir: string;
+      rootPackage: Package;
+      packages: Package[];
+    };
+    config: Config$1;
+    warnings: readonly string[];
+  }, CommandExit | ConfigError | WorkspaceError, FileSystem.FileSystem | Path.Path>;
+  refuseUnsupported: (project: Project) => Effect.Effect<undefined, UnsupportedFeatureError | WorkspaceError, never>;
+  readChangesets: (packages: Packages, since?: string | undefined) => Effect.Effect<{
+    releases: ReadonlyArray<Release>;
+    summary: string;
+    id: string;
+  }[], ChangesetParseError | GitError | WorkspaceError, never>;
+  version: (options: {
+    readonly cwd: string;
+    readonly ignore?: ReadonlyArray<string> | undefined;
+  }) => Effect.Effect<ReleasePlan, ChangelogError | ChangesetParseError | CommandExit | ConfigError | FormatterError | GitError | JsonEditError | ReleasePlanError | UnsupportedFeatureError | WorkspaceError, FileSystem.FileSystem | Path.Path>;
+  status: (options: {
+    readonly cwd: string;
+    readonly since?: string | undefined;
+    readonly output?: string | undefined;
+  }) => Effect.Effect<ReleasePlan, ChangesetParseError | CommandExit | ConfigError | GitError | ReleasePlanError | UnsupportedFeatureError | WorkspaceError, FileSystem.FileSystem | Path.Path>;
+  changedPackages: (project: Project, ref?: string | undefined) => Effect.Effect<Package[], GitError, never>;
+  writeChangeset: (project: Project, changeset: Changeset) => Effect.Effect<{
+    id: string;
+    file: string;
+  }, FormatterError | WorkspaceError, never>;
+}> & {
+  readonly make: Effect.Effect<{
+    load: (cwd: string) => Effect.Effect<{
+      packages: {
+        rootDir: string;
+        rootPackage: Package;
+        packages: Package[];
+      };
+      config: Config$1;
+      warnings: readonly string[];
+    }, CommandExit | ConfigError | WorkspaceError, FileSystem.FileSystem | Path.Path>;
+    refuseUnsupported: (project: Project) => Effect.Effect<undefined, UnsupportedFeatureError | WorkspaceError, never>;
+    readChangesets: (packages: Packages, since?: string | undefined) => Effect.Effect<{
+      releases: ReadonlyArray<Release>;
+      summary: string;
+      id: string;
+    }[], ChangesetParseError | GitError | WorkspaceError, never>;
+    version: (options: {
+      readonly cwd: string;
+      readonly ignore?: ReadonlyArray<string> | undefined;
+    }) => Effect.Effect<ReleasePlan, ChangelogError | ChangesetParseError | CommandExit | ConfigError | FormatterError | GitError | JsonEditError | ReleasePlanError | UnsupportedFeatureError | WorkspaceError, FileSystem.FileSystem | Path.Path>;
+    status: (options: {
+      readonly cwd: string;
+      readonly since?: string | undefined;
+      readonly output?: string | undefined;
+    }) => Effect.Effect<ReleasePlan, ChangesetParseError | CommandExit | ConfigError | GitError | ReleasePlanError | UnsupportedFeatureError | WorkspaceError, FileSystem.FileSystem | Path.Path>;
+    changedPackages: (project: Project, ref?: string | undefined) => Effect.Effect<Package[], GitError, never>;
+    writeChangeset: (project: Project, changeset: Changeset) => Effect.Effect<{
+      id: string;
+      file: string;
+    }, FormatterError | WorkspaceError, never>;
+  }, never, FileSystem.FileSystem | Formatter | Git | Path.Path>;
+};
+export declare class Changesets extends Changesets_base {
+  static readonly layer: Layer.Layer<Changesets, never, import("effect/process/ChildProcessSpawner").ChildProcessSpawner | FileSystem.FileSystem | Path.Path>;
+}
+export declare const changesetCommand: Command.Command<"changeset", {
+  readonly empty: boolean;
+  readonly open: boolean;
+  readonly since: Option.Option<string>;
+  readonly message: Option.Option<string>;
+  readonly major: string[];
+  readonly minor: string[];
+  readonly patch: string[];
+} | {}, {}, ChangelogError | ChangesetParseError | CommandExit | ConfigError | FormatterError | GitError | JsonEditError | ReleasePlanError | UnsupportedFeatureError | WorkspaceError, Changesets | ChildProcessSpawner.ChildProcessSpawner | Prompt.Environment>;
+/** Runs the CLI; expected failures print their message once and exit non-zero. */
+export declare const main: Effect.Effect<void, ChangelogError | ChangesetParseError | CommandExit | ConfigError | FormatterError | GitError | JsonEditError | ReleasePlanError | UnsupportedFeatureError | WorkspaceError | import("effect/cli/CliError").CliError, Changesets | ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | Path.Path | import("effect/Stdio").Stdio | import("effect/Terminal").Terminal>;
+/** Parses one changeset file; the failure is the message changesets would print. */
+export declare const parseChangesetFile: (contents: string) => Result.Result<Changeset, string>;
+export declare const assembleReleasePlan: (changesets: ReadonlyArray<NewChangeset>, packages: Packages, config: Config$1) => Result.Result<ReleasePlan, string>;
+export type { Changeset, ComprehensiveRelease, DEPENDENCY_TYPES, DependencyRanges, DependencyType, NewChangeset, NewChangesetWithCommit, Package, PackageJson, Packages, Project, Release, ReleasePlan, VersionType };

package/dist/index.mjs

@@ -0,0 +1 @@
+export { o as ChangelogError, s as ChangesetParseError, r as Changesets, c as CommandExit, l as ConfigError, u as FormatterError, d as GitError, f as JsonEditError, p as ReleasePlanError, m as UnsupportedFeatureError, h as WorkspaceError, i as assembleReleasePlan, t as changesetCommand, n as main, a as parseChangesetFile } from "./cli-_8EGJc1S.mjs";

package/package.json

@@ -1,6 +1,67 @@
 {
-  "name": "@maple-dev/changesets",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "@maple-dev/changesets",
+	"version": "0.1.0",
+	"description": "A dependency-free, Effect-based drop-in for the @changesets/cli add, version and status commands",
+	"keywords": [
+		"changesets",
+		"changelog",
+		"effect",
+		"monorepo",
+		"release",
+		"versioning"
+	],
+	"homepage": "https://github.com/MapleTechLabs/changesets#readme",
+	"bugs": {
+		"url": "https://github.com/MapleTechLabs/changesets/issues"
+	},
+	"license": "MIT",
+	"author": "Makisuo, Inc.",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/MapleTechLabs/changesets.git"
+	},
+	"bin": {
+		"changeset": "./dist/bin.mjs"
+	},
+	"files": [
+		"dist",
+		"README.md"
+	],
+	"type": "module",
+	"sideEffects": false,
+	"exports": {
+		".": {
+			"types": "./dist/index.d.mts",
+			"import": "./dist/index.mjs",
+			"default": "./dist/index.mjs"
+		},
+		"./package.json": "./package.json"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"engines": {
+		"node": ">=22"
+	},
+	"scripts": {
+		"build": "tsdown",
+		"typecheck": "tsc --noEmit",
+		"test": "vitest run",
+		"prepublishOnly": "bun run typecheck && bun run test && bun run build",
+		"changeset": "bun src/bin.ts",
+		"version-packages": "bun src/bin.ts version",
+		"release": "bun scripts/publish.ts",
+		"record-reference": "bun scripts/record-reference.ts"
+	},
+	"dependencies": {
+		"@effect/platform-node": "^4.1.0",
+		"effect": "^4.1.0"
+	},
+	"devDependencies": {
+		"@types/node": "^24.19.2",
+		"tsdown": "^0.23.0",
+		"typescript": "^7.0.2",
+		"vitest": "^5.0.5"
+	},
+	"packageManager": "bun@1.4.4"
+}