Removed some unused internals, cleaned up and decoupled (#77)

mattiamanzati · web-flow · commit b289c885c05a · 2025-09-13T11:02:33.000+02:00
diff --git a/.changeset/cruel-days-design.md b/.changeset/cruel-days-design.md
@@ -0,0 +1,5 @@
+---
+"effect-vscode": minor
+---
+
+Removed some unused internals, cleaned up and decoupled from some vscode/dap specifics
diff --git a/.gitignore b/.gitignore
@@ -3,5 +3,6 @@ dist
 node_modules
 .vscode-test/
 *.vsix
+*.tsbuildinfo
 .DS_Store
 .direnv/
diff --git a/package.json b/package.json
@@ -237,12 +237,12 @@
         },
         {
           "command": "effect.enableSpanStackIgnoreList",
-          "when": "view === effect-debug-span-stack && effect:skipSpanStackIgnoreList === false",
+          "when": "view === effect-debug-span-stack && effect:spanStackIgnoreListEnabled === false",
           "group": "navigation"
         },
         {
           "command": "effect.disableSpanStackIgnoreList",
-          "when": "view === effect-debug-span-stack && effect:skipSpanStackIgnoreList === true",
+          "when": "view === effect-debug-span-stack && effect:spanStackIgnoreListEnabled === true",
           "group": "navigation"
         }
       ],
diff --git a/src/Clients.ts b/src/Clients.ts
@@ -183,14 +183,17 @@ const runServer = (port: number) =>
       Effect.provideService(ClientsContext, yield* ClientsContext)
     )
 
-    yield* Stream.runForEach(clients.changes, (client) =>
-      Effect.gen(function*() {
-        yield* executeCommand("setContext", "effect:hasClients", HashSet.size(client) > 0)
-      })).pipe(Effect.forkScoped)
+    yield* Stream.runForEach(
+      clients.changes,
+      (client) => (executeCommand("setContext", "effect:hasClients", HashSet.size(client) > 0))
+    ).pipe(
+      Effect.asVoid,
+      Effect.forkScoped
+    )
 
     const serverHandle = yield* FiberHandle.make()
     yield* Stream.runForEach(running.changes, ({ running }) =>
-      Effect.gen(function*(_) {
+      Effect.gen(function*() {
         yield* running
           ? FiberHandle.run(serverHandle, run, { onlyIfMissing: true })
           : FiberHandle.clear(serverHandle)
diff --git a/src/ContextProvider.ts b/src/ContextProvider.ts
@@ -27,27 +27,25 @@ export const ContextProviderLive = treeDataProvider<TreeNode>("effect-context")(
       let nodes: Array<TagNode> = []
 
       const capture = (threadId?: number) =>
-        Effect.gen(function*(_) {
-          const sessionOption = yield* _(SubscriptionRef.get(debug.session))
+        Effect.gen(function*() {
+          const sessionOption = yield* (SubscriptionRef.get(debug.session))
           if (Option.isNone(sessionOption)) {
             nodes = []
           } else {
             const session = sessionOption.value
-            const pairs = yield* _(session.context(threadId))
+            const pairs = yield* (session.context(threadId))
             nodes = pairs.map((_) => new TagNode(_))
           }
-          yield* _(refresh(Option.none()))
+          yield* (refresh(Option.none()))
         })
 
-      yield* Stream.fromPubSub(debug.messages).pipe(
+      yield* Stream.fromPubSub(debug.events).pipe(
         Stream.mapEffect((event) => {
-          if (event.type !== "event") return Effect.void
-
-          switch (event.event) {
-            case "stopped": {
-              return Effect.delay(capture(event.body?.threadId), 500)
+          switch (event._tag) {
+            case "DebuggerThreadStopped": {
+              return Effect.delay(capture(event.threadId), 500)
             }
-            case "continued": {
+            case "DebuggerThreadContinued": {
               nodes = []
               return refresh(Option.none())
             }
diff --git a/src/DebugBreakpointsProvider.ts b/src/DebugBreakpointsProvider.ts
@@ -79,17 +79,13 @@ export const DebugBreakpointsProviderLive = treeDataProvider<TreeNode>("effect-d
         Effect.forkScoped
       )
 
-      yield* Stream.fromPubSub(debug.messages).pipe(
+      yield* Stream.fromPubSub(debug.events).pipe(
         Stream.mapEffect((event) => {
-          if (event.type !== "event") return Effect.void
-
-          switch (event.event) {
-            case "stopped": {
-              return capture(false, event.body?.threadId).pipe(
-                Effect.delay(500)
-              )
+          switch (event._tag) {
+            case "DebuggerThreadStopped": {
+              return capture(false, event.threadId)
             }
-            case "continued": {
+            case "DebuggerThreadContinued": {
               pauseValueToRevealNodes = []
               return refresh(Option.none())
             }
diff --git a/src/DebugEnv.ts b/src/DebugEnv.ts
@@ -12,13 +12,22 @@ import * as DebugChannel from "./DebugChannel"
 import { compiledInstrumentationString } from "./instrumentation/instrumentation.compiled"
 import { listenFork, VsCodeContext } from "./VsCode"
 
+export class DebuggerThreadStopped extends Data.TaggedClass("DebuggerThreadStopped")<{
+  threadId?: number
+}> {}
+
+export class DebuggerThreadContinued extends Data.TaggedClass("DebuggerThreadContinued")<{
+  threadId: number
+}> {}
+
+export type DebuggerEvent = DebuggerThreadStopped | DebuggerThreadContinued
+
 export interface DebugEnvImpl {
   readonly session: SubscriptionRef.SubscriptionRef<Option.Option<Session>>
-  readonly messages: PubSub.PubSub<Message>
+  readonly events: PubSub.PubSub<DebuggerEvent>
 }
 
 export interface Session {
-  readonly vscode: vscode.DebugSession
   readonly context: (threadId: number | undefined) => Effect.Effect<Array<ContextPair>>
   readonly currentSpanStack: (threadId: number | undefined) => Effect.Effect<Array<SpanStackEntry>>
   readonly currentFibers: (threadId: number | undefined) => Effect.Effect<Array<FiberEntry>>
@@ -27,23 +36,6 @@ export interface Session {
   readonly getAndUnsetPauseStateToReveal: (threadId: number | undefined) => Effect.Effect<PauseStateToReveal>
 }
 
-export type Message =
-  | {
-    readonly seq: number
-    readonly type: "event"
-    readonly event: string
-    readonly body?: any
-  }
-  | {
-    readonly seq: number
-    readonly type: "response"
-    readonly command: string
-    readonly success: boolean
-    readonly body?: any
-    readonly request_seq: number
-    readonly message?: string
-  }
-
 export class DebugEnv extends Context.Tag("effect-vscode/DebugEnv")<
   DebugEnv,
   DebugEnvImpl
@@ -52,7 +44,7 @@ export class DebugEnv extends Context.Tag("effect-vscode/DebugEnv")<
     DebugEnv,
     Effect.gen(function*() {
       const sessionRef = yield* SubscriptionRef.make(Option.none<Session>())
-      const messages = yield* PubSub.sliding<Message>(100)
+      const events = yield* PubSub.sliding<DebuggerEvent>(100)
 
       yield* listenFork(
         vscode.debug.onDidChangeActiveDebugSession,
@@ -65,7 +57,6 @@ export class DebugEnv extends Context.Tag("effect-vscode/DebugEnv")<
           return yield* SubscriptionRef.set(
             sessionRef,
             Option.some({
-              vscode: session,
               context: (threadId) => withDebugChannel(getContext(threadId)),
               currentSpanStack: (threadId) => withDebugChannel(getCurrentSpanStack(threadId)),
               currentFibers: (threadId) => withDebugChannel(getCurrentFibers(threadId)),
@@ -83,14 +74,24 @@ export class DebugEnv extends Context.Tag("effect-vscode/DebugEnv")<
           createDebugAdapterTracker(_) {
             return {
               onDidSendMessage(message) {
-                messages.unsafeOffer(message)
+                if (message.type === "event" && message.event === "stopped") {
+                  events.unsafeOffer(
+                    new DebuggerThreadStopped({ threadId: message.body?.threadId })
+                  )
+                } else if (message.type === "event" && message.event === "continued") {
+                  events.unsafeOffer(
+                    new DebuggerThreadContinued({
+                      threadId: message.body?.threadId
+                    })
+                  )
+                }
               }
             }
           }
         })
       )
 
-      return { session: sessionRef, messages }
+      return { session: sessionRef, events }
     })
   )
 }
diff --git a/src/DebugFibersProvider.ts b/src/DebugFibersProvider.ts
@@ -31,28 +31,26 @@ export const DebugFibersProviderLive = treeDataProvider<TreeNode>("effect-debug-
       })
 
       const capture = (threadId?: number) =>
-        Effect.gen(function*(_) {
-          const sessionOption = yield* _(SubscriptionRef.get(debug.session))
+        Effect.gen(function*() {
+          const sessionOption = yield* (SubscriptionRef.get(debug.session))
           if (Option.isNone(sessionOption)) {
             nodes = []
           } else {
             const session = sessionOption.value
-            const pairs = yield* _(session.currentFibers(threadId))
+            const pairs = yield* (session.currentFibers(threadId))
             nodes = pairs.map((_) => new TreeNode(_))
           }
-          yield* _(refresh(Option.none()))
+          yield* (refresh(Option.none()))
         })
 
-      yield* Stream.fromPubSub(debug.messages).pipe(
+      yield* Stream.fromPubSub(debug.events).pipe(
         Stream.mapEffect((event) =>
           Effect.gen(function*() {
-            if (event.type !== "event") return
-
-            switch (event.event) {
-              case "stopped": {
-                return yield* Effect.delay(capture(event.body?.threadId), 500)
+            switch (event._tag) {
+              case "DebuggerThreadStopped": {
+                return yield* Effect.delay(capture(event.threadId), 500)
               }
-              case "continued": {
+              case "DebuggerThreadContinued": {
                 nodes = []
                 return yield* refresh(Option.none())
               }
diff --git a/src/DebugSpanStackProvider.ts b/src/DebugSpanStackProvider.ts
@@ -50,19 +50,20 @@ export const DebugSpanStackProviderLive = treeDataProvider<TreeNode>("effect-deb
         "ignoreList",
         []
       )
-      let skipIgnoreList = false
       yield* ignoreList.changes.pipe(Stream.mapEffect(() => refresh(Option.none())), Stream.runDrain, Effect.forkScoped)
 
-      const setSkipIgnoreList = (skip: boolean) => {
-        skipIgnoreList = skip
+      let ignoreListEnabled = true
+      const setIgnoreListEnabled = (enabled: boolean) => {
+        ignoreListEnabled = enabled
         return refresh(Option.none()).pipe(
-          Effect.zipRight(executeCommand("setContext", "effect:skipSpanStackIgnoreList", skip))
+          Effect.zipRight(executeCommand("setContext", "effect:spanStackIgnoreListEnabled", enabled))
         )
       }
+      yield* setIgnoreListEnabled(true)
 
       const visibleNodes = Effect.gen(function*() {
         const ignoreListValue = yield* ignoreList.get
-        if (skipIgnoreList || ignoreListValue.length === 0) return nodes
+        if (!ignoreListEnabled || ignoreListValue.length === 0) return nodes
         const result = []
         for (const node of nodes) {
           if (node._tag === "SpanNode") {
@@ -80,8 +81,8 @@ export const DebugSpanStackProviderLive = treeDataProvider<TreeNode>("effect-deb
       }).pipe(Effect.asSome)
 
       // allows to toggle ignore list
-      yield* registerCommand("effect.enableSpanStackIgnoreList", () => setSkipIgnoreList(true))
-      yield* registerCommand("effect.disableSpanStackIgnoreList", () => setSkipIgnoreList(false))
+      yield* registerCommand("effect.enableSpanStackIgnoreList", () => setIgnoreListEnabled(true))
+      yield* registerCommand("effect.disableSpanStackIgnoreList", () => setIgnoreListEnabled(false))
 
       // jump to span location
       yield* registerCommand("effect.revealSpanLocation", (node: TreeNode) => {
@@ -95,27 +96,25 @@ export const DebugSpanStackProviderLive = treeDataProvider<TreeNode>("effect-deb
       })
 
       const capture = (threadId?: number) =>
-        Effect.gen(function*(_) {
-          const sessionOption = yield* _(SubscriptionRef.get(debug.session))
+        Effect.gen(function*() {
+          const sessionOption = yield* (SubscriptionRef.get(debug.session))
           if (Option.isNone(sessionOption)) {
             nodes = []
           } else {
             const session = sessionOption.value
-            const pairs = yield* _(session.currentSpanStack(threadId))
+            const pairs = yield* (session.currentSpanStack(threadId))
             nodes = pairs.map((_) => new SpanNode(_))
           }
-          yield* _(refresh(Option.none()))
+          yield* (refresh(Option.none()))
         })
 
-      yield* Stream.fromPubSub(debug.messages).pipe(
+      yield* Stream.fromPubSub(debug.events).pipe(
         Stream.mapEffect((event) => {
-          if (event.type !== "event") return Effect.void
-
-          switch (event.event) {
-            case "stopped": {
-              return Effect.delay(capture(event.body?.threadId), 500)
+          switch (event._tag) {
+            case "DebuggerThreadStopped": {
+              return Effect.delay(capture(event.threadId), 500)
             }
-            case "continued": {
+            case "DebuggerThreadContinued": {
               nodes = []
               return refresh(Option.none())
             }
diff --git a/src/LayerHoverProvider.ts b/src/LayerHoverProvider.ts
@@ -2,8 +2,9 @@ import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import { executeCommandCatch, isExtensionInstalled, registerTextEditorCommand, revealCode } from "./VsCode"
 
-export const LayerHoverProviderLive = Effect.gen(function*() {
-  yield* registerTextEditorCommand("effect.showLayerMermaid", (textEditor) =>
+export const LayerHoverProviderLive = registerTextEditorCommand(
+  "effect.showLayerMermaid",
+  (textEditor) =>
     Effect.gen(function*() {
       // current range
       const position = textEditor.selection.active
@@ -27,5 +28,5 @@ export const LayerHoverProviderLive = Effect.gen(function*() {
           yield* executeCommandCatch("mermaidChart.preview", mermaidCode)
         }
       }
-    }))
-}).pipe(Layer.scopedDiscard)
+    })
+).pipe(Layer.scopedDiscard)
diff --git a/src/TreeCommands.ts b/src/TreeCommands.ts
@@ -4,9 +4,7 @@ import * as vscode from "vscode"
 import type { InfoNode } from "./SpanProvider"
 import { registerCommand } from "./VsCode"
 
-export const TreeCommandsLive = Effect.gen(function*() {
-  yield* registerCommand(
-    "effect.copyInfoValue",
-    (infoNode: InfoNode) => Effect.promise(() => vscode.env.clipboard.writeText(infoNode.description))
-  )
-}).pipe(Layer.effectDiscard)
+export const TreeCommandsLive = registerCommand(
+  "effect.copyInfoValue",
+  (infoNode: InfoNode) => Effect.promise(() => vscode.env.clipboard.writeText(infoNode.description))
+).pipe(Layer.effectDiscard)
diff --git a/src/VsCode.ts b/src/VsCode.ts
diff --git a/tsconfig.tsbuildinfo b/tsconfig.tsbuildinfo

-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +"effect-vscode": minor
 +---
++
 +Removed some unused internals, cleaned up and decoupled from some vscode/dap specifics
Original file line number	Diff line number	Diff line change
`@@ -237,12 +237,12 @@`
`237`	`237`	`},`
`238`	`238`	`{`
`239`	`239`	`"command": "effect.enableSpanStackIgnoreList",`
`240`		`- "when": "view === effect-debug-span-stack && effect:skipSpanStackIgnoreList === false",`
	`240`	`+ "when": "view === effect-debug-span-stack && effect:spanStackIgnoreListEnabled === false",`
`241`	`241`	`"group": "navigation"`
`242`	`242`	`},`
`243`	`243`	`{`
`244`	`244`	`"command": "effect.disableSpanStackIgnoreList",`
`245`		`- "when": "view === effect-debug-span-stack && effect:skipSpanStackIgnoreList === true",`
	`245`	`+ "when": "view === effect-debug-span-stack && effect:spanStackIgnoreListEnabled === true",`
`246`	`246`	`"group": "navigation"`
`247`	`247`	`}`
`248`	`248`	`],`