Kit Langton
58ad84d53e
Convert Snapshot from a promise-based namespace with Instance ALS reads
to an Effect service on the Instances LayerMap.
- SnapshotService with ChildProcessSpawner for git subprocess execution
and Effect FileSystem for file operations (replaces Process.run and
raw fs calls)
- Nothrow git helper that always returns { code, text, stderr }, with
spawn failure details preserved in stderr
- Hourly cleanup via Effect.forkScoped + Schedule.spaced (replaces
Scheduler.register)
- Promise facade preserved for all existing callers
- Parallelized before/after git show in diffFull
- Add worktree to InstanceContext.Shape (needed for --work-tree flag)
- Add Instance.current getter for single ALS read
- Extract repeated git config flags into GIT_CORE/GIT_CFG/GIT_CFG_QUOTE
constants
- Platform layers (NodeChildProcessSpawner, NodeFileSystem, NodePath)
provided directly on the service layer
54 lines
1.6 KiB
TypeScript
54 lines
1.6 KiB
TypeScript
import { ConfigProvider, Layer, ManagedRuntime } from "effect";
|
|
import { InstanceContext } from "../../src/effect/instance-context";
|
|
import { Instance } from "../../src/project/instance";
|
|
|
|
/** ConfigProvider that enables the experimental file watcher. */
|
|
export const watcherConfigLayer = ConfigProvider.layer(
|
|
ConfigProvider.fromUnknown({
|
|
OPENCODE_EXPERIMENTAL_FILEWATCHER: "true",
|
|
OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER: "false",
|
|
}),
|
|
);
|
|
|
|
/**
|
|
* Boot an Instance with the given service layers and run `body` with
|
|
* the ManagedRuntime. Cleanup is automatic — the runtime is disposed
|
|
* and Instance context is torn down when `body` completes.
|
|
*
|
|
* Layers may depend on InstanceContext (provided automatically).
|
|
* Pass extra layers via `options.provide` (e.g. ConfigProvider.layer).
|
|
*/
|
|
export function withServices<S>(
|
|
directory: string,
|
|
layer: Layer.Layer<S, any, InstanceContext>,
|
|
body: (rt: ManagedRuntime.ManagedRuntime<S, never>) => Promise<void>,
|
|
options?: { provide?: Layer.Layer<never>[] },
|
|
) {
|
|
return Instance.provide({
|
|
directory,
|
|
fn: async () => {
|
|
const ctx = Layer.sync(InstanceContext, () =>
|
|
InstanceContext.of({
|
|
directory: Instance.directory,
|
|
worktree: Instance.worktree,
|
|
project: Instance.project,
|
|
}),
|
|
);
|
|
let resolved: Layer.Layer<S> = Layer.fresh(layer).pipe(
|
|
Layer.provide(ctx),
|
|
) as any;
|
|
if (options?.provide) {
|
|
for (const l of options.provide) {
|
|
resolved = resolved.pipe(Layer.provide(l)) as any;
|
|
}
|
|
}
|
|
const rt = ManagedRuntime.make(resolved);
|
|
try {
|
|
await body(rt);
|
|
} finally {
|
|
await rt.dispose();
|
|
}
|
|
},
|
|
});
|
|
}
|