expandai 0.0.2 → 0.0.3

package/src/Init/HarnessDetector.ts

@@ -0,0 +1,77 @@
+import { homedir } from 'node:os'
+import { FileSystem, Path } from '@effect/platform'
+import { NodeFileSystem, NodePath } from '@effect/platform-node'
+import { Effect, Option, Schema } from 'effect'
+import { InitHarness, type InitHarnesses } from './Domain.js'
+
+interface HarnessDetectionInput {
+	readonly cwd?: string
+	readonly environment?: Readonly<Record<string, string | undefined>>
+	readonly hint?: typeof InitHarness.Type
+}
+
+const HARNESS_ORDER: InitHarnesses = ['claude-code', 'cursor', 'opencode', 'codex']
+
+function enabled(value: string | undefined): boolean {
+	return value !== undefined && value !== '' && value !== '0' && value !== 'false'
+}
+
+function currentHarness(
+	environment: Readonly<Record<string, string | undefined>>,
+): Option.Option<typeof InitHarness.Type> {
+	const explicit = Schema.decodeUnknownOption(InitHarness)(environment.EXPANDAI_HARNESS)
+	if (Option.isSome(explicit)) return explicit
+	if (enabled(environment.CLAUDECODE)) return Option.some('claude-code')
+	if (environment.CURSOR_TRACE_ID !== undefined) return Option.some('cursor')
+	if (environment.CODEX_RUN_ID !== undefined) return Option.some('codex')
+	return Option.none()
+}
+
+export class HarnessDetector extends Effect.Service<HarnessDetector>()('@expandai/cli/Init/HarnessDetector', {
+	dependencies: [NodeFileSystem.layer, NodePath.layer],
+	effect: Effect.gen(function* () {
+		const fileSystem = yield* FileSystem.FileSystem
+		const path = yield* Path.Path
+
+		const detect = Effect.fn('HarnessDetector.detect')(function* (input: HarnessDetectionInput = {}) {
+			const environment = input.environment ?? process.env
+			const cwd = input.cwd ?? environment.PWD ?? process.cwd()
+			const home = environment.HOME ?? homedir()
+			const candidates = new Map<typeof InitHarness.Type, string[]>([
+				['claude-code', [path.join(home, '.claude'), path.join(cwd, '.claude')]],
+				['cursor', [path.join(home, '.cursor'), path.join(cwd, '.cursor')]],
+				[
+					'opencode',
+					[path.join(home, '.config', 'opencode'), path.join(cwd, '.opencode'), path.join(cwd, 'opencode.json')],
+				],
+				['codex', [path.join(home, '.codex'), path.join(cwd, '.codex')]],
+			])
+			const detected = new Set<typeof InitHarness.Type>()
+			const current = currentHarness(environment)
+			if (Option.isSome(current)) detected.add(current.value)
+			if (input.hint !== undefined) detected.add(input.hint)
+			// Collect, then filter. The previous version mutated `detected` from inside
+			// a `tap` under unbounded concurrency — safe on one thread, but it read as
+			// a race and expressed "keep the ones that exist" as a side effect.
+			const present = yield* Effect.forEach(
+				HARNESS_ORDER,
+				(harness) =>
+					Effect.exists(candidates.get(harness) ?? [], (candidate) =>
+						fileSystem.exists(candidate).pipe(Effect.orElseSucceed(() => false)),
+					).pipe(Effect.map((exists) => ({ harness, exists }))),
+				{ concurrency: 'unbounded' },
+			)
+			for (const { harness, exists } of present) if (exists) detected.add(harness)
+			return HARNESS_ORDER.filter((harness) => detected.has(harness))
+		})
+
+		/** The harness this process is running inside, when it announces itself. */
+		const detectCurrent = Effect.fnUntraced(function* (input: Pick<HarnessDetectionInput, 'environment'> = {}) {
+			// Reads ambient `process.env` when no environment is supplied, so it stays
+			// an Effect — but it does no work worth a span.
+			return currentHarness(input.environment ?? process.env)
+		})
+
+		return { detect, detectCurrent } as const
+	}),
+}) {}

package/src/Init/HarnessRegistry.ts

@@ -0,0 +1,87 @@
+import { Effect, Schema } from 'effect'
+import { ClaudeAdapter } from './ClaudeAdapter.js'
+import type { InitHarness, InitScope } from './Domain.js'
+import type { HarnessConfigurationError, HarnessInspection, HarnessInspectionError } from './HarnessAdapter.js'
+import { CodexAdapter, CursorAdapter, OpencodeAdapter } from './StandardAdapters.js'
+
+export interface HarnessAdapterContract {
+	readonly harness: InitHarness
+	readonly inspect: (scope: InitScope) => Effect.Effect<HarnessInspection, HarnessInspectionError>
+	readonly configure: (scope: InitScope) => Effect.Effect<HarnessInspection, HarnessConfigurationError>
+}
+
+interface HarnessRegistryContract {
+	readonly inspect: (
+		harness: InitHarness,
+		scope: InitScope,
+	) => Effect.Effect<HarnessInspection, UnsupportedInitHarnessError | HarnessInspectionError>
+	readonly configure: (
+		harness: InitHarness,
+		scope: InitScope,
+	) => Effect.Effect<HarnessInspection, UnsupportedInitHarnessError | HarnessConfigurationError>
+}
+
+export class UnsupportedInitHarnessError extends Schema.TaggedError<UnsupportedInitHarnessError>()(
+	'UnsupportedInitHarnessError',
+	{
+		harness: Schema.String,
+	},
+) {
+	get message() {
+		return `No init adapter is registered for ${this.harness}`
+	}
+}
+
+function makeRegistry(adapters: ReadonlyArray<HarnessAdapterContract>): HarnessRegistryContract {
+	const adaptersByHarness = new Map(adapters.map((adapter) => [adapter.harness, adapter]))
+
+	const find = Effect.fn('HarnessRegistry.find')(function* (harness: InitHarness) {
+		const adapter = adaptersByHarness.get(harness)
+		if (adapter === undefined) {
+			return yield* new UnsupportedInitHarnessError({ harness })
+		}
+		return adapter
+	})
+
+	const inspect = Effect.fn('HarnessRegistry.inspect')(function* (harness: InitHarness, scope: InitScope) {
+		const adapter = yield* find(harness)
+		return yield* adapter.inspect(scope)
+	})
+
+	const configure = Effect.fn('HarnessRegistry.configure')(function* (harness: InitHarness, scope: InitScope) {
+		const adapter = yield* find(harness)
+		return yield* adapter.configure(scope)
+	})
+
+	return { inspect, configure }
+}
+
+/**
+ * `Default` is the **real** registry, wired to the four adapters.
+ *
+ * It used to be `sync: () => makeRegistry([])` — an empty registry that reported
+ * every harness as unsupported. Nothing consumed it, because `main.ts` and the
+ * tests both built `DefaultWithoutDependencies` with a registry supplied by
+ * hand; but `InitService` and `StatusService` still *declared* it in their
+ * `dependencies`, so the declaration was decorative and would have silently
+ * produced an empty registry for anyone who reached for the obvious layer.
+ * `Effect.Service` always generates `Default`, so the fix is to make it correct
+ * rather than to remove it.
+ */
+export class HarnessRegistry extends Effect.Service<HarnessRegistry>()('@expandai/cli/Init/HarnessRegistry', {
+	dependencies: [ClaudeAdapter.Default, CursorAdapter.Default, OpencodeAdapter.Default, CodexAdapter.Default],
+	effect: Effect.gen(function* () {
+		const adapters = yield* Effect.all([ClaudeAdapter, CursorAdapter, OpencodeAdapter, CodexAdapter])
+		return makeRegistry(adapters)
+	}),
+}) {
+	/**
+	 * The adapters are statically known at the composition root, so the contract
+	 * is enforced by the type. The previous version took `ReadonlyArray<object>`
+	 * and proved membership at runtime by walking prototypes and calling
+	 * `Context.isTag` on the constructor — reflection standing in for a type, plus
+	 * an error channel for a condition the compiler already rules out.
+	 */
+	static readonly fromAdapters = (adapters: ReadonlyArray<HarnessAdapterContract>) =>
+		HarnessRegistry.make(makeRegistry(adapters))
+}