Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.

next
ts 320 lines 12.8 KB
Raw
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 });