Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.
| 1 | import { Effect, FileSystem, Option, Path, Schema } from 'effect'; |
| 2 | import { getPackages } from '@manypkg/get-packages'; |
| 3 | import { readChangesets } from '@changesets/read'; |
| 4 | import { readConfig } from '@changesets/config'; |
| 5 | import { assembleReleasePlan } from '@changesets/assemble-release-plan'; |
| 6 | import { applyReleasePlan } from '@changesets/apply-release-plan'; |
| 7 | import type { Config, NewChangeset, Packages, ReleasePlan } from '@changesets/types'; |
| 8 | import semver from 'semver'; |
| 9 | import { betaSnapshot, pythonVersion, stableByDefault } from './channel'; |
| 10 | import { LANGUAGES, Language, PRIMARY_TARGETS, PYTHON_RELEASE_MARKER, languageOf } from './lanes'; |
| 11 | import { |
| 12 | discoverPythonPackages, |
| 13 | synchronizePythonMetadata, |
| 14 | type PythonMetadataOptions, |
| 15 | type PythonReleasePackage, |
| 16 | } from './python-metadata'; |
| 17 | import { ensure, fail, fromPromise, sameJson, sha256Hex, writeFile } from './runtime'; |
| 18 | |
| 19 | export { PYTHON_RELEASE_MARKER } from './lanes'; |
| 20 | |
| 21 | const Bump = Schema.Literals(['major', 'minor', 'patch']); |
| 22 | type Bump = typeof Bump.Type; |
| 23 | |
| 24 | export const ReleaseChoice = Schema.Literals(['auto', 'major', 'minor', 'patch', 'skip']); |
| 25 | export type ReleaseChoice = typeof ReleaseChoice.Type; |
| 26 | export const autoByDefault = ReleaseChoice.pipe( |
| 27 | Schema.withDecodingDefaultKey(Effect.succeed('auto' as const)) |
| 28 | ); |
| 29 | |
| 30 | const PlanningRun = Schema.String.check(Schema.isPattern(/^[1-9][0-9]*$/)); |
| 31 | |
| 32 | export const ReleaseOptions = Schema.Struct({ |
| 33 | typescript: autoByDefault, |
| 34 | python: autoByDefault, |
| 35 | channel: stableByDefault, |
| 36 | /** The run that plans the release; a beta's versions end with it. */ |
| 37 | run: Schema.optionalKey(PlanningRun), |
| 38 | }); |
| 39 | export type SdkReleaseOptions = typeof ReleaseOptions.Encoded; |
| 40 | type Choices = Record<Language, ReleaseChoice>; |
| 41 | |
| 42 | const Changeset = Schema.Struct({ |
| 43 | id: Schema.String.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]*$/)), |
| 44 | summary: Schema.String, |
| 45 | releases: Schema.Array( |
| 46 | Schema.Struct({ |
| 47 | name: Schema.String, |
| 48 | type: Schema.Literals(['major', 'minor', 'patch', 'none']), |
| 49 | }) |
| 50 | ), |
| 51 | }); |
| 52 | const Release = Schema.Struct({ |
| 53 | name: Schema.String, |
| 54 | type: Bump, |
| 55 | oldVersion: Schema.String, |
| 56 | newVersion: Schema.String, |
| 57 | changesets: Schema.Array(Schema.String), |
| 58 | language: Language, |
| 59 | }); |
| 60 | export const SdkReleasePlan = Schema.Struct({ |
| 61 | schemaVersion: Schema.Literal(1), |
| 62 | inputFingerprint: Schema.String, |
| 63 | choices: Schema.Struct({ |
| 64 | typescript: ReleaseChoice, |
| 65 | python: ReleaseChoice, |
| 66 | channel: stableByDefault, |
| 67 | run: Schema.optionalKey(PlanningRun), |
| 68 | }), |
| 69 | recommended: Schema.Array(Release), |
| 70 | releases: Schema.Array(Release), |
| 71 | changesets: Schema.Array(Changeset), |
| 72 | retainedChangesets: Schema.Array(Changeset), |
| 73 | }); |
| 74 | export type SdkReleasePlan = typeof SdkReleasePlan.Type; |
| 75 | export type SdkRelease = typeof Release.Type; |
| 76 | |
| 77 | const decodePlan = Schema.decodeUnknownEffect(SdkReleasePlan); |
| 78 | |
| 79 | /** Changesets' APIs take mutable notes. */ |
| 80 | const toNewChangeset = (note: typeof Changeset.Type): NewChangeset => ({ |
| 81 | ...note, |
| 82 | releases: [...note.releases], |
| 83 | }); |
| 84 | const byName = (a: { name: string }, b: { name: string }) => a.name.localeCompare(b.name); |
| 85 | const byId = (a: { id: string }, b: { id: string }) => a.id.localeCompare(b.id); |
| 86 | |
| 87 | /** An explicit bump overrides each note's recommendation; `auto` and `skip` keep it. */ |
| 88 | const explicitBump = (choice: ReleaseChoice): Option.Option<Bump> => |
| 89 | Schema.is(Bump)(choice) ? Option.some(choice) : Option.none(); |
| 90 | |
| 91 | const isStable = (version: string) => |
| 92 | semver.valid(version) !== null && semver.prerelease(version) === null; |
| 93 | |
| 94 | const isSdkTarget = (pkg: Packages['packages'][number], config: Config) => |
| 95 | !config.ignore.includes(pkg.packageJson.name) && |
| 96 | (pkg.packageJson.name === PYTHON_RELEASE_MARKER || |
| 97 | (!pkg.packageJson.private && pkg.packageJson.name.startsWith('@composio/'))); |
| 98 | |
| 99 | const loadInputs = (cwd: string) => |
| 100 | Effect.gen(function* () { |
| 101 | const fs = yield* FileSystem.FileSystem; |
| 102 | const path = yield* Path.Path; |
| 103 | if (yield* fs.exists(path.resolve(cwd, '.changeset/pre.json'))) |
| 104 | return yield* fail('Stable SDK planning does not consume Changesets prerelease state'); |
| 105 | const packages = yield* fromPromise(() => getPackages(cwd)); |
| 106 | const result = yield* fromPromise(() => readConfig(cwd, packages)); |
| 107 | if (!result.config) |
| 108 | return yield* fail(`Invalid Changesets config: ${result.errors.join('; ')}`); |
| 109 | const unversionedPrivate = packages.packages |
| 110 | .filter(pkg => pkg.packageJson.private && pkg.packageJson.name !== PYTHON_RELEASE_MARKER) |
| 111 | .map(pkg => pkg.packageJson.name); |
| 112 | const config: Config = { |
| 113 | ...result.config, |
| 114 | ignore: [...new Set([...result.config.ignore, ...unversionedPrivate])].sort(), |
| 115 | }; |
| 116 | const changesets = (yield* Schema.decodeUnknownEffect(Schema.Array(Changeset))( |
| 117 | yield* fromPromise(() => readChangesets(cwd)) |
| 118 | )) |
| 119 | .toSorted(byId) |
| 120 | .map(toNewChangeset); |
| 121 | const allowed = new Set( |
| 122 | packages.packages.filter(pkg => isSdkTarget(pkg, config)).map(pkg => pkg.packageJson.name) |
| 123 | ); |
| 124 | for (const note of changesets) |
| 125 | for (const entry of note.releases) |
| 126 | yield* ensure( |
| 127 | allowed.has(entry.name), |
| 128 | `${entry.name} is not an SDK release target (${note.id})` |
| 129 | ); |
| 130 | const marker = packages.packages.find(pkg => pkg.packageJson.name === PYTHON_RELEASE_MARKER); |
| 131 | const python: ReadonlyArray<PythonReleasePackage> = marker |
| 132 | ? yield* discoverPythonPackages(cwd) |
| 133 | : []; |
| 134 | if (marker) { |
| 135 | yield* ensure(marker.packageJson.private === true, 'Python release marker must be private'); |
| 136 | for (const pkg of python) |
| 137 | yield* ensure( |
| 138 | pkg.version === marker.packageJson.version, |
| 139 | `Python metadata baseline mismatch for ${pkg.name}` |
| 140 | ); |
| 141 | } |
| 142 | const fingerprint = yield* sha256Hex( |
| 143 | JSON.stringify({ |
| 144 | config, |
| 145 | packages: packages.packages |
| 146 | .map(pkg => ({ directory: path.relative(cwd, pkg.dir), manifest: pkg.packageJson })) |
| 147 | .sort((a, b) => a.directory.localeCompare(b.directory)), |
| 148 | changesets, |
| 149 | python, |
| 150 | }) |
| 151 | ); |
| 152 | return { packages, config, changesets, python, allowed, fingerprint }; |
| 153 | }); |
| 154 | |
| 155 | const selectedReleases = (native: ReleasePlan) => |
| 156 | Schema.decodeUnknownEffect(Schema.Array(Release))( |
| 157 | native.releases |
| 158 | .filter(release => release.type !== 'none') |
| 159 | .map(release => ({ ...release, language: languageOf(release.name) })) |
| 160 | .sort(byName) |
| 161 | ); |
| 162 | |
| 163 | /** Applies per-language choices to authored notes; skipped entries stay for a later release. */ |
| 164 | const splitNotes = (notes: ReadonlyArray<NewChangeset>, choices: Choices) => { |
| 165 | const selected: NewChangeset[] = []; |
| 166 | const retained: NewChangeset[] = []; |
| 167 | for (const note of notes) { |
| 168 | const isSkipped = (entry: NewChangeset['releases'][number]) => |
| 169 | choices[languageOf(entry.name)] === 'skip'; |
| 170 | const releases = note.releases |
| 171 | .filter(entry => !isSkipped(entry)) |
| 172 | .map(entry => ({ |
| 173 | ...entry, |
| 174 | type: Option.getOrElse(explicitBump(choices[languageOf(entry.name)]), () => entry.type), |
| 175 | })); |
| 176 | const remaining = note.releases.filter(isSkipped); |
| 177 | if (releases.length) selected.push({ ...note, releases }); |
| 178 | if (remaining.length) retained.push({ ...note, releases: remaining }); |
| 179 | } |
| 180 | return { selected, retained }; |
| 181 | }; |
| 182 | |
| 183 | /** An explicit bump for a language without notes becomes an honest primary-group maintenance release. */ |
| 184 | const maintenanceNotes = ( |
| 185 | selected: ReadonlyArray<NewChangeset>, |
| 186 | choices: Choices, |
| 187 | allowed: Set<string> |
| 188 | ) => |
| 189 | Effect.forEach( |
| 190 | LANGUAGES.flatMap(language => |
| 191 | Option.match(explicitBump(choices[language]), { |
| 192 | onNone: () => [], |
| 193 | onSome: type => |
| 194 | selected.some(note => note.releases.some(entry => languageOf(entry.name) === language)) |
| 195 | ? [] |
| 196 | : [{ language, type }], |
| 197 | }) |
| 198 | ), |
| 199 | ({ language, type }) => |
| 200 | Effect.gen(function* () { |
| 201 | for (const name of PRIMARY_TARGETS[language]) |
| 202 | yield* ensure(allowed.has(name), `Missing primary SDK release target ${name}`); |
| 203 | return { |
| 204 | id: `sdk-maintenance-${language}`, |
| 205 | summary: 'Maintenance release. No user-facing changes were recorded.', |
| 206 | releases: PRIMARY_TARGETS[language].map(name => ({ name, type })), |
| 207 | } satisfies NewChangeset; |
| 208 | }) |
| 209 | ); |
| 210 | |
| 211 | /** |
| 212 | * How Changesets computes versions for a channel: the normal bump for stable, a snapshot of it |
| 213 | * for beta. A beta needs its planning run, which makes its versions unique. |
| 214 | */ |
| 215 | const versioning = (choices: typeof ReleaseOptions.Type, config: Config) => |
| 216 | Effect.gen(function* () { |
| 217 | if (choices.channel === 'stable') return { config, snapshot: undefined }; |
| 218 | if (choices.run === undefined) return yield* fail('A beta plan needs its planning run'); |
| 219 | const { config: snapshot, parameters } = betaSnapshot(choices.run); |
| 220 | return { config: { ...config, snapshot }, snapshot: parameters }; |
| 221 | }); |
| 222 | |
| 223 | export const createSdkReleasePlan = (cwd: string, options: SdkReleaseOptions = {}) => |
| 224 | Effect.gen(function* () { |
| 225 | const choices = yield* Schema.decodeUnknownEffect(ReleaseOptions)(options); |
| 226 | const inputs = yield* loadInputs(cwd); |
| 227 | const { config, snapshot } = yield* versioning(choices, inputs.config); |
| 228 | for (const pkg of inputs.packages.packages) |
| 229 | if (inputs.allowed.has(pkg.packageJson.name)) |
| 230 | yield* ensure( |
| 231 | isStable(pkg.packageJson.version), |
| 232 | `SDK version must be stable for ${pkg.packageJson.name}` |
| 233 | ); |
| 234 | const notes = inputs.changesets; |
| 235 | const recommendation = assembleReleasePlan(notes, inputs.packages, config, undefined, snapshot); |
| 236 | const { selected, retained } = splitNotes(notes, choices); |
| 237 | selected.push(...(yield* maintenanceNotes(selected, choices, inputs.allowed))); |
| 238 | const native = assembleReleasePlan(selected, inputs.packages, config, undefined, snapshot); |
| 239 | const releases = yield* selectedReleases(native); |
| 240 | for (const release of releases) |
| 241 | yield* ensure( |
| 242 | inputs.allowed.has(release.name), |
| 243 | `Unexpected SDK release target ${release.name}` |
| 244 | ); |
| 245 | return yield* decodePlan({ |
| 246 | schemaVersion: 1, |
| 247 | inputFingerprint: inputs.fingerprint, |
| 248 | choices: { |
| 249 | typescript: choices.typescript, |
| 250 | python: choices.python, |
| 251 | channel: choices.channel, |
| 252 | ...(choices.run === undefined ? {} : { run: choices.run }), |
| 253 | }, |
| 254 | recommended: yield* selectedReleases(recommendation), |
| 255 | releases, |
| 256 | changesets: native.changesets, |
| 257 | retainedChangesets: retained, |
| 258 | }); |
| 259 | }); |
| 260 | |
| 261 | const serializeChangeset = (note: NewChangeset) => |
| 262 | `---\n${note.releases.map(entry => `${JSON.stringify(entry.name)}: ${entry.type}`).join('\n')}\n---\n\n${note.summary}\n`; |
| 263 | |
| 264 | /** Writes the planned versions, changelogs, retained notes and Python metadata to `cwd`. */ |
| 265 | export const applySdkReleasePlan = ( |
| 266 | cwd: string, |
| 267 | value: SdkReleasePlan, |
| 268 | options: PythonMetadataOptions = {} |
| 269 | ) => |
| 270 | Effect.gen(function* () { |
| 271 | const fs = yield* FileSystem.FileSystem; |
| 272 | const path = yield* Path.Path; |
| 273 | const plan = yield* decodePlan(value); |
| 274 | if (plan.releases.length === 0) return; |
| 275 | const inputs = yield* loadInputs(cwd); |
| 276 | yield* ensure( |
| 277 | inputs.fingerprint === plan.inputFingerprint, |
| 278 | 'Release inputs changed after planning; create a new plan' |
| 279 | ); |
| 280 | yield* ensure( |
| 281 | sameJson(yield* createSdkReleasePlan(cwd, plan.choices), plan), |
| 282 | 'Release data changed from the selected source plan' |
| 283 | ); |
| 284 | const versionOf = (name: string) => |
| 285 | inputs.packages.packages.find(pkg => pkg.packageJson.name === name)?.packageJson.version; |
| 286 | for (const release of plan.releases) |
| 287 | yield* ensure( |
| 288 | inputs.allowed.has(release.name) && versionOf(release.name) === release.oldVersion, |
| 289 | `Invalid release target ${release.name}` |
| 290 | ); |
| 291 | const { config, snapshot } = yield* versioning( |
| 292 | yield* Schema.decodeUnknownEffect(ReleaseOptions)(plan.choices), |
| 293 | inputs.config |
| 294 | ); |
| 295 | const native = assembleReleasePlan( |
| 296 | plan.changesets.map(toNewChangeset), |
| 297 | inputs.packages, |
| 298 | config, |
| 299 | undefined, |
| 300 | snapshot |
| 301 | ); |
| 302 | yield* ensure( |
| 303 | sameJson(yield* selectedReleases(native), plan.releases), |
| 304 | 'Release targets changed from the selected Changesets plan' |
| 305 | ); |
| 306 | // A snapshot pins internal dependencies to the exact beta versions. |
| 307 | yield* fromPromise(() => |
| 308 | applyReleasePlan(native, inputs.packages, config, snapshot !== undefined, cwd) |
| 309 | ); |
| 310 | for (const note of plan.retainedChangesets) |
| 311 | yield* writeFile( |
| 312 | path.resolve(cwd, '.changeset', `${note.id}.md`), |
| 313 | serializeChangeset(toNewChangeset(note)) |
| 314 | ); |
| 315 | const retainedIds = new Set(plan.retainedChangesets.map(note => note.id)); |
| 316 | for (const note of plan.changesets.filter(note => !retainedIds.has(note.id))) |
| 317 | yield* fs.remove(path.resolve(cwd, '.changeset', `${note.id}.md`), { force: true }); |
| 318 | const python = plan.releases.find(release => release.name === PYTHON_RELEASE_MARKER); |
| 319 | if (python) yield* synchronizePythonMetadata(cwd, pythonVersion(python.newVersion), options); |
| 320 | }); |