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 165 lines 4.93 KB
Raw
1 import * as BunPath from '@effect/platform-bun/BunPath';
2 import * as BunFileSystem from '@effect/platform-bun/BunFileSystem';
3 import { Context, Data, Effect, Layer, Option, Schema, pipe } from 'effect';
4 import * as FileSystem from 'effect/FileSystem';
5 import * as Path from 'effect/Path';
6
7 const toError = (e: unknown): Error => (e instanceof Error ? e : new Error(String(e)));
8
9 /**
10 * Error thrown when a package manager detection fails.
11 */
12 export class JsPackageManagerError extends Data.TaggedError('services/JsPackageManagerError')<{
13 readonly cause: Error;
14 readonly message: string;
15 }> {}
16
17 /**
18 * Valid JavaScript package manager names recognised by Composio.
19 */
20 export type PackageManager = 'pnpm' | 'bun' | 'yarn' | 'npm';
21
22 const LOCK_FILES: Record<PackageManager, string> = {
23 pnpm: 'pnpm-lock.yaml',
24 bun: 'bun.lockb',
25 yarn: 'yarn.lock',
26 npm: 'package-lock.json',
27 };
28
29 const PM_PREFERENCE: PackageManager[] = ['pnpm', 'bun', 'yarn', 'npm'];
30
31 export interface JsPackageManagerDetectorShape {
32 readonly detectJsPackageManager: (
33 cwd: string
34 ) => Effect.Effect<PackageManager, JsPackageManagerError>;
35 }
36
37 // Service that attempts to detect the package manager of the project in the current working directory.
38 const makeJsPackageManagerDetector = Effect.gen(function* () {
39 yield* Effect.logDebug('[JsPackageManagerDetector] Identifying JS package manager...');
40
41 const fs = yield* FileSystem.FileSystem;
42 const path = yield* Path.Path;
43
44 const parsePackageManager = (pm: string): Option.Option<PackageManager> => {
45 if (pm.startsWith('pnpm@')) return Option.some('pnpm');
46 if (pm.startsWith('bun@')) return Option.some('bun');
47 if (pm.startsWith('yarn@')) return Option.some('yarn');
48 if (pm.startsWith('npm@')) return Option.some('npm');
49 return Option.none();
50 };
51
52 const PackageJsonSchema = Schema.Struct({
53 packageManager: Schema.optional(Schema.String),
54 }).annotate({ identifier: 'package.json' });
55
56 const detectFromPackageJson = (
57 cwd: string
58 ): Effect.Effect<Option.Option<PackageManager>, JsPackageManagerError> =>
59 Effect.gen(function* () {
60 const contentEffect = pipe(
61 fs.readFileString(path.join(cwd, 'package.json')),
62 Effect.catchTag('PlatformError', e =>
63 Effect.fail(
64 new JsPackageManagerError({ cause: e, message: 'Failed to read package.json' })
65 )
66 )
67 );
68
69 const content = yield* Effect.option(contentEffect);
70
71 if (Option.isNone(content)) {
72 return Option.none();
73 }
74
75 const json = yield* Effect.try({
76 try: () => JSON.parse(content.value) as unknown,
77 catch: e =>
78 new JsPackageManagerError({
79 cause: toError(e),
80 message: 'Failed to parse package.json',
81 }),
82 });
83
84 const decoded = yield* pipe(
85 Schema.decodeUnknownEffect(PackageJsonSchema)(json),
86 Effect.mapError(
87 e =>
88 new JsPackageManagerError({
89 cause: toError(e),
90 message: 'Failed to decode package.json',
91 })
92 )
93 );
94
95 return Option.fromNullishOr(decoded.packageManager).pipe(Option.flatMap(parsePackageManager));
96 });
97
98 const detectRecursive = (
99 cwd: string
100 ): Effect.Effect<Option.Option<PackageManager>, JsPackageManagerError> =>
101 Effect.gen(function* () {
102 const fromPackageJson = yield* detectFromPackageJson(cwd);
103 if (Option.isSome(fromPackageJson)) {
104 return fromPackageJson;
105 }
106
107 const parentDir = path.dirname(cwd);
108 if (parentDir === cwd) {
109 return Option.none();
110 }
111
112 return yield* detectRecursive(parentDir);
113 });
114
115 const detectJsPackageManager = (
116 cwd: string
117 ): Effect.Effect<PackageManager, JsPackageManagerError> =>
118 Effect.gen(function* () {
119 const files = yield* pipe(
120 fs.readDirectory(cwd),
121 Effect.mapError(
122 e =>
123 new JsPackageManagerError({
124 cause: toError(e),
125 message: `Failed to read directory ${cwd}`,
126 })
127 )
128 );
129
130 const fileNames = files.map(f => f.toLowerCase());
131
132 for (const pm of PM_PREFERENCE) {
133 if (fileNames.includes(LOCK_FILES[pm])) {
134 return pm;
135 }
136 }
137
138 const result = yield* detectRecursive(cwd);
139
140 if (Option.isSome(result)) {
141 return result.value;
142 }
143
144 return yield* Effect.fail(
145 new JsPackageManagerError({
146 cause: new Error('Recursive lookup exhausted'),
147 message: 'Failed to detect package manager',
148 })
149 );
150 });
151
152 return {
153 detectJsPackageManager,
154 };
155 });
156
157 export class JsPackageManagerDetector extends Context.Service<
158 JsPackageManagerDetector,
159 JsPackageManagerDetectorShape
160 >()('services/JsPackageManagerDetector') {
161 static readonly Default: Layer.Layer<JsPackageManagerDetector> = Layer.effect(
162 JsPackageManagerDetector,
163 makeJsPackageManagerDetector
164 ).pipe(Layer.provide(Layer.mergeAll(BunFileSystem.layer, BunPath.layer)));
165 }