expandai 0.0.4 → 0.0.5

package/src/Init/HarnessDetector.ts

@@ -1,77 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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))
-}