lalph 0.3.95 → 0.3.97

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lalph",
   "type": "module",
-  "version": "0.3.95",
+  "version": "0.3.97",
   "publishConfig": {
     "access": "public"
   },
@@ -44,8 +44,8 @@
     "@linear/sdk": "^78.0.0",
     "@octokit/plugin-rest-endpoint-methods": "^17.0.0",
     "@octokit/types": "^16.0.0",
-    "@typescript/native-preview": "7.0.0-dev.20260320.1",
-    "clanka": "^0.2.21",
+    "@typescript/native-preview": "7.0.0-dev.20260321.1",
+    "clanka": "^0.2.26",
     "concurrently": "^9.2.1",
     "effect": "4.0.0-beta.36",
     "husky": "^9.1.7",

package/src/Clanka.ts

@@ -1,4 +1,5 @@
-import { Agent, OutputFormatter, SemanticSearch } from "clanka"
+import * as Agent from "clanka/Agent"
+import * as OutputFormatter from "clanka/OutputFormatter"
 import {
   Cause,
   Config,
@@ -18,6 +19,7 @@ import { NodeHttpClient } from "@effect/platform-node"
 import type { Prompt } from "effect/unstable/ai"
 import { OpenAiClient, OpenAiEmbeddingModel } from "@effect/ai-openai"
 import { Worktree } from "./Worktree.ts"
+import { SemanticSearch } from "clanka"
 
 export const ClankaMuxerLayer = Layer.effectDiscard(
   Effect.gen(function* () {

package/src/CurrentIssueSource.ts

@@ -8,15 +8,14 @@ import {
   Schema,
   ScopedRef,
   ServiceMap,
+  SubscriptionRef,
 } from "effect"
 import { allProjects, CurrentProjectId, Setting, Settings } from "./Settings.ts"
 import { LinearIssueSource } from "./Linear.ts"
 import { Prompt } from "effect/unstable/cli"
 import { GithubIssueSource } from "./Github.ts"
-import { IssueSource } from "./IssueSource.ts"
+import { IssuesChange, IssueSource } from "./IssueSource.ts"
 import { PlatformServices } from "./shared/platform.ts"
-import { atomRuntime } from "./shared/runtime.ts"
-import { Atom, Reactivity } from "effect/unstable/reactivity"
 import type { PrdIssue } from "./domain/PrdIssue.ts"
 import type { Project, ProjectId } from "./domain/Project.ts"
 import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner"
@@ -109,6 +108,16 @@ export class CurrentIssueSource extends ServiceMap.Service<
           )
 
       const proxy = IssueSource.of({
+        ref: (projectId) =>
+          ScopedRef.get(ref).pipe(
+            Effect.flatMap((source) => source.ref(projectId)),
+            unlessRalph(
+              projectId,
+              SubscriptionRef.make<IssuesChange>(
+                IssuesChange.Internal({ issues: [] }),
+              ),
+            ),
+          ),
         issues: (projectId) =>
           ScopedRef.get(ref).pipe(
             Effect.flatMap((source) => source.issues(projectId)),
@@ -186,35 +195,16 @@ const refreshSchedule = Schedule.exponential(100, 1.5).pipe(
   Schedule.either(Schedule.spaced("30 seconds")),
 )
 
-// Atoms
-
-export const issueSourceRuntime = atomRuntime(
-  CurrentIssueSource.layer.pipe(Layer.orDie),
-)
-
-export const currentIssuesAtom = Atom.family((projectId: ProjectId) =>
-  pipe(
-    issueSourceRuntime.atom(
-      IssueSource.use((s) => s.issues(projectId)).pipe(
-        Effect.withSpan("currentIssuesAtom"),
-      ),
-    ),
-    atomRuntime.withReactivity([`issues:${projectId}`]),
-    Atom.withRefresh("30 seconds"),
-    Atom.keepAlive,
-  ),
-)
-
 // Helpers
 
 const getCurrentIssues = (projectId: ProjectId) =>
-  Atom.getResult(currentIssuesAtom(projectId), {
-    suspendOnWaiting: true,
-  })
+  IssueSource.use((s) =>
+    pipe(s.ref(projectId), Effect.flatMap(SubscriptionRef.get)),
+  )
 
 export const checkForWork = Effect.fnUntraced(function* (project: Project) {
   if (project.gitFlow === "ralph") return
-  const issues = yield* getCurrentIssues(project.id)
+  const { issues } = yield* getCurrentIssues(project.id)
   const hasIncomplete = issues.some(
     (issue) => issue.state === "todo" && issue.blockedBy.length === 0,
   )
@@ -225,9 +215,8 @@ export const checkForWork = Effect.fnUntraced(function* (project: Project) {
 
 export const resetInProgress = Effect.gen(function* () {
   const source = yield* IssueSource
-  const reactivity = yield* Reactivity.Reactivity
   const projectId = yield* CurrentProjectId
-  const issues = yield* getCurrentIssues(projectId)
+  const { issues } = yield* getCurrentIssues(projectId)
   const inProgress = issues.filter(
     (issue): issue is PrdIssue & { id: string } =>
       issue.state === "in-progress" && issue.id !== null,
@@ -242,7 +231,7 @@ export const resetInProgress = Effect.gen(function* () {
         state: "todo",
       }),
     { concurrency: 5, discard: true },
-  ).pipe(reactivity.withBatch)
+  )
 })
 
 export class NoMoreWork extends Schema.ErrorClass<NoMoreWork>(

package/src/IssueSource.ts

@@ -1,15 +1,36 @@
-import { Effect, Option, Schema, ServiceMap } from "effect"
+import {
+  Array,
+  Data,
+  Duration,
+  Effect,
+  Option,
+  Schema,
+  ScopedCache,
+  ServiceMap,
+  Stream,
+  SubscriptionRef,
+  pipe,
+} from "effect"
 import type { PrdIssue } from "./domain/PrdIssue.ts"
-import { Reactivity } from "effect/unstable/reactivity"
 import type { ProjectId } from "./domain/Project.ts"
 import type { CurrentProjectId, Settings } from "./Settings.ts"
 import type { CliAgentPreset } from "./domain/CliAgentPreset.ts"
 import type { Environment } from "effect/unstable/cli/Prompt"
 import type { QuitError } from "effect/Terminal"
 
+export type IssuesChange = Data.TaggedEnum<{
+  Internal: { issues: ReadonlyArray<PrdIssue> }
+  External: { issues: ReadonlyArray<PrdIssue> }
+}>
+export const IssuesChange = Data.taggedEnum<IssuesChange>()
+
 export class IssueSource extends ServiceMap.Service<
   IssueSource,
   {
+    readonly ref: (
+      projectId: ProjectId,
+    ) => Effect.Effect<SubscriptionRef.SubscriptionRef<IssuesChange>>
+
     readonly issues: (
       projectId: ProjectId,
     ) => Effect.Effect<ReadonlyArray<PrdIssue>, IssueSourceError>
@@ -71,31 +92,70 @@ export class IssueSource extends ServiceMap.Service<
     ) => Effect.Effect<void, IssueSourceError>
   }
 >()("lalph/IssueSource") {
-  static make(impl: IssueSource["Service"]) {
+  static make(impl: Omit<IssueSource["Service"], "ref">) {
     return Effect.gen(function* () {
-      const reactivity = yield* Reactivity.Reactivity
+      const refs = yield* ScopedCache.make({
+        lookup: Effect.fnUntraced(function* (projectId: ProjectId) {
+          const ref = yield* SubscriptionRef.make<IssuesChange>(
+            IssuesChange.Internal({
+              issues: yield* pipe(
+                impl.issues(projectId),
+                Effect.orElseSucceed(Array.empty),
+              ),
+            }),
+          )
+
+          yield* SubscriptionRef.changes(ref).pipe(
+            Stream.switchMap((_) =>
+              impl.issues(projectId).pipe(
+                Effect.tap((issues) =>
+                  SubscriptionRef.set(ref, IssuesChange.External({ issues })),
+                ),
+                Effect.delay(Duration.seconds(30)),
+                Stream.fromEffectDrain,
+              ),
+            ),
+            Stream.runDrain,
+            Effect.forkScoped,
+          )
+
+          return ref
+        }),
+        capacity: Number.MAX_SAFE_INTEGER,
+      })
+
+      const update = Effect.fnUntraced(function* (
+        projectId: ProjectId,
+        issues: ReadonlyArray<PrdIssue>,
+      ) {
+        const ref = yield* ScopedCache.get(refs, projectId)
+        yield* SubscriptionRef.set(ref, IssuesChange.Internal({ issues }))
+      })
+
+      const updateIssues = (projectId: ProjectId) =>
+        pipe(
+          impl.issues(projectId),
+          Effect.tap((issues) => update(projectId, issues)),
+        )
+
       return IssueSource.of({
         ...impl,
+        ref: (projectId) => ScopedCache.get(refs, projectId),
+        issues: updateIssues,
         createIssue: (projectId, issue) =>
-          reactivity.mutation(
-            {
-              issues: [projectId],
-            },
+          pipe(
             impl.createIssue(projectId, issue),
+            Effect.tap(updateIssues(projectId)),
           ),
         updateIssue: (options) =>
-          reactivity.mutation(
-            {
-              issues: [options.projectId],
-            },
+          pipe(
             impl.updateIssue(options),
+            Effect.tap(updateIssues(options.projectId)),
           ),
         cancelIssue: (projectId, issueId) =>
-          reactivity.mutation(
-            {
-              issues: [projectId],
-            },
+          pipe(
             impl.cancelIssue(projectId, issueId),
+            Effect.tap(updateIssues(projectId)),
           ),
       })
     })

package/src/Prd.ts

@@ -10,12 +10,12 @@ import {
   Semaphore,
   ServiceMap,
   Stream,
+  SubscriptionRef,
 } from "effect"
 import { Worktree } from "./Worktree.ts"
 import { PrdIssue } from "./domain/PrdIssue.ts"
 import { IssueSource, IssueSourceError } from "./IssueSource.ts"
-import { AtomRegistry, Reactivity } from "effect/unstable/reactivity"
-import { CurrentIssueSource, currentIssuesAtom } from "./CurrentIssueSource.ts"
+import { CurrentIssueSource } from "./CurrentIssueSource.ts"
 import { CurrentProjectId, Settings } from "./Settings.ts"
 
 export class Prd extends ServiceMap.Service<
@@ -46,9 +46,7 @@ export class Prd extends ServiceMap.Service<
     const worktree = yield* Worktree
     const pathService = yield* Path.Path
     const fs = yield* FileSystem.FileSystem
-    const reactivity = yield* Reactivity.Reactivity
     const source = yield* IssueSource
-    const registry = yield* AtomRegistry.AtomRegistry
     const projectId = yield* CurrentProjectId
 
     let chosenIssueId: string | null = null
@@ -60,10 +58,9 @@ export class Prd extends ServiceMap.Service<
       const yaml = yield* fs.readFileString(prdFile)
       return PrdIssue.arrayFromYaml(yaml)
     })
-    const getCurrentIssues = AtomRegistry.getResult(
-      registry,
-      currentIssuesAtom(projectId),
-      { suspendOnWaiting: true },
+    const issuesRef = yield* source.ref(projectId)
+    const getCurrentIssues = SubscriptionRef.get(issuesRef).pipe(
+      Effect.map((i) => i.issues),
     )
 
     const syncSemaphore = Semaphore.makeUnsafe(1)
@@ -203,7 +200,6 @@ export class Prd extends ServiceMap.Service<
         { concurrency: "unbounded" },
       )
     }).pipe(
-      reactivity.withBatch,
       Effect.uninterruptible,
       syncSemaphore.withPermit,
       Effect.withSpan("Prd.sync"),
@@ -242,10 +238,10 @@ export class Prd extends ServiceMap.Service<
       Effect.forkScoped,
     )
 
-    yield* AtomRegistry.toStreamResult(
-      registry,
-      currentIssuesAtom(projectId),
-    ).pipe(Stream.runForEach(updateSync), Effect.forkScoped)
+    yield* SubscriptionRef.changes(issuesRef).pipe(
+      Stream.runForEach((s) => updateSync(s.issues)),
+      Effect.forkScoped,
+    )
 
     const findById = Effect.fnUntraced(function* (issueId: string) {
       const current = yield* getCurrentIssues
@@ -277,22 +273,13 @@ export class Prd extends ServiceMap.Service<
   static layerNoWorktree = Layer.effect(this, this.make)
   static layer = this.layerNoWorktree.pipe(Layer.provideMerge(Worktree.layer))
   static layerProvided = this.layer.pipe(
-    Layer.provide([
-      AtomRegistry.layer,
-      Reactivity.layer,
-      CurrentIssueSource.layer,
-      Settings.layer,
-    ]),
+    Layer.provide([CurrentIssueSource.layer, Settings.layer]),
   )
   static layerLocal = this.layerNoWorktree.pipe(
     Layer.provideMerge(Worktree.layerLocal),
   )
   static layerLocalProvided = this.layerLocal.pipe(
-    Layer.provide([
-      AtomRegistry.layer,
-      Reactivity.layer,
-      CurrentIssueSource.layer,
-    ]),
+    Layer.provide([CurrentIssueSource.layer]),
   )
   static layerNoop = Layer.succeed(this, {
     path: "",

package/src/TaskTools.ts

@@ -1,13 +1,4 @@
-import {
-  Deferred,
-  Effect,
-  MutableRef,
-  Option,
-  Random,
-  Schema,
-  ServiceMap,
-  Struct,
-} from "effect"
+import { Deferred, Effect, Random, Schema, ServiceMap, Struct } from "effect"
 import { Tool, Toolkit } from "effect/unstable/ai"
 import { PrdIssue } from "./domain/PrdIssue.ts"
 import { IssueSource } from "./IssueSource.ts"
@@ -24,17 +15,6 @@ export class ChosenTaskDeferred extends ServiceMap.Reference(
   },
 ) {}
 
-export class CurrentTaskRef extends ServiceMap.Service<
-  CurrentTaskRef,
-  MutableRef.MutableRef<PrdIssue>
->()("lalph/TaskTools/CurrentTaskRef") {
-  static update(f: (prev: PrdIssue) => PrdIssue) {
-    return Effect.serviceOption(CurrentTaskRef).pipe(
-      Effect.map(Option.map((ref) => MutableRef.updateAndGet(ref, f))),
-    )
-  }
-}
-
 const Task = Schema.Struct({
   id: Schema.String.annotate({
     documentation: "The unique identifier of the task.",
@@ -180,7 +160,6 @@ export const TaskToolsHandlers = TaskToolsWithChoose.toLayer(
           Effect.annotateLogs({ taskId: options.taskId }),
         )
         const projectId = yield* CurrentProjectId
-        yield* CurrentTaskRef.update((prev) => prev.update(options))
         yield* source.updateIssue({
           projectId,
           issueId: options.taskId,

package/src/cli.ts

@@ -12,7 +12,6 @@ import { commandSource } from "./commands/source.ts"
 import PackageJson from "../package.json" with { type: "json" }
 import { TracingLayer } from "./Tracing.ts"
 import { MinimumLogLevel } from "effect/References"
-import { atomRuntime, lalphMemoMap } from "./shared/runtime.ts"
 import { PlatformServices } from "./shared/platform.ts"
 import { commandProjects } from "./commands/projects.ts"
 import { commandSh } from "./commands/sh.ts"
@@ -32,14 +31,11 @@ commandRoot.pipe(
   Command.provide(TracingLayer),
   Command.provide(({ verbose }) => {
     if (!verbose) return Layer.empty
-    const logLevel = Layer.succeed(MinimumLogLevel, "All")
-    atomRuntime.addGlobalLayer(logLevel)
-    return logLevel
+    return Layer.succeed(MinimumLogLevel, "All")
   }),
   Command.run({
     version: PackageJson.version,
   }),
   Effect.provide(PlatformServices),
-  Effect.provideService(Layer.CurrentMemoMap, lalphMemoMap),
   NodeRuntime.runMain,
 )

package/src/commands/root.ts

@@ -9,16 +9,15 @@ import {
   FileSystem,
   Iterable,
   Layer,
-  MutableRef,
   Option,
   Path,
   PlatformError,
   Result,
-  Schedule,
   Schema,
   Scope,
   Semaphore,
   Stream,
+  SubscriptionRef,
 } from "effect"
 import { PromptGen } from "../PromptGen.ts"
 import { Prd } from "../Prd.ts"
@@ -28,7 +27,6 @@ import { IssueSource, IssueSourceError } from "../IssueSource.ts"
 import {
   checkForWork,
   CurrentIssueSource,
-  currentIssuesAtom,
   resetInProgress,
 } from "../CurrentIssueSource.ts"
 import { GithubCli } from "../Github/Cli.ts"
@@ -60,7 +58,6 @@ import type { TimeoutError } from "effect/Cause"
 import type { ChildProcessSpawner } from "effect/unstable/process"
 import type { AiError } from "effect/unstable/ai/AiError"
 import type { PrdIssue } from "../domain/PrdIssue.ts"
-import { CurrentTaskRef } from "../TaskTools.ts"
 import type { OutputFormatter } from "clanka"
 import { ClankaMuxerLayer, SemanticSearchLayer } from "../Clanka.ts"
 import { agentResearcher } from "../Agents/researcher.ts"
@@ -250,14 +247,10 @@ const run = Effect.fnUntraced(
             gitFlow,
           })
 
-      const issueRef = MutableRef.make(
-        chosenTask.prd.update({
-          state: "in-progress",
-        }),
-      )
+      const issueSemaphore = Semaphore.makeUnsafe(1)
       const steer = yield* taskUpdateSteer({
         issueId: taskId,
-        current: issueRef,
+        semaphore: issueSemaphore,
       })
 
       const exitCode = yield* agentWorker({
@@ -268,11 +261,7 @@ const run = Effect.fnUntraced(
         research: researchResult,
         steer,
         currentTask: CurrentTask.task({ task: chosenTask.prd }),
-      }).pipe(
-        Effect.provideService(CurrentTaskRef, issueRef),
-        catchStallInReview,
-        Effect.withSpan("Main.agentWorker"),
-      )
+      }).pipe(catchStallInReview, Effect.withSpan("Main.agentWorker"))
       yield* Effect.log(`Agent exited with code: ${exitCode}`)
 
       // 3. Review task
@@ -823,18 +812,18 @@ export const commandRoot = Command.make("lalph", {
 const watchTaskState = Effect.fnUntraced(function* (options: {
   readonly issueId: string
 }) {
-  const registry = yield* AtomRegistry.AtomRegistry
   const projectId = yield* CurrentProjectId
+  const source = yield* IssueSource
+  const ref = yield* source.ref(projectId)
 
-  return yield* AtomRegistry.toStreamResult(
-    registry,
-    currentIssuesAtom(projectId),
-  ).pipe(
-    Stream.retry(Schedule.forever),
-    Stream.orDie,
-    Stream.debounce(Duration.seconds(10)),
-    Stream.runForEach((issues) => {
-      const issue = issues.find((entry) => entry.id === options.issueId)
+  return yield* SubscriptionRef.changes(ref).pipe(
+    Stream.filterMap((issues) => {
+      if (issues._tag === "Internal") return Result.failVoid
+      return Result.succeed(
+        issues.issues.find((entry) => entry.id === options.issueId),
+      )
+    }),
+    Stream.runForEach((issue) => {
       if (issue?.state === "in-progress" || issue?.state === "in-review") {
         return Effect.void
       }
@@ -851,26 +840,29 @@ const watchTaskState = Effect.fnUntraced(function* (options: {
 
 const taskUpdateSteer = Effect.fnUntraced(function* (options: {
   readonly issueId: string
-  readonly current: MutableRef.MutableRef<PrdIssue>
+  readonly semaphore: Semaphore.Semaphore
 }) {
-  const registry = yield* AtomRegistry.AtomRegistry
   const projectId = yield* CurrentProjectId
+  const source = yield* IssueSource
+  const ref = yield* source.ref(projectId)
+  let current: PrdIssue | undefined = undefined
 
-  return AtomRegistry.toStreamResult(
-    registry,
-    currentIssuesAtom(projectId),
-  ).pipe(
-    Stream.drop(1),
-    Stream.retry(Schedule.forever),
-    Stream.orDie,
-    Stream.debounce(Duration.seconds(10)),
+  return SubscriptionRef.changes(ref).pipe(
     Stream.filterMap((issues) => {
-      const issue = issues.find((entry) => entry.id === options.issueId)
+      const issue = issues.issues.find((entry) => entry.id === options.issueId)
       if (!issue) return Result.failVoid
-      if (!issue.isChangedComparedTo(options.current.current)) {
+      if (!current) {
+        current = issue
+        return Result.failVoid
+      }
+      if (!issue.isChangedComparedTo(current)) {
+        return Result.failVoid
+      }
+      current = issue
+      console.log("issue change", issues._tag)
+      if (issues._tag === "Internal") {
         return Result.failVoid
       }
-      MutableRef.set(options.current, issue)
       return Result.succeed(`The task has been updated by the user. Here is the latest information:
 
 # ${issue.title}

package/src/domain/PrdIssue.ts

@@ -107,6 +107,7 @@ export class PrdIssue extends Schema.Class<PrdIssue>("PrdIssue")({
   }
 
   update(options: {
+    readonly id?: string | undefined
     readonly title?: string | undefined
     readonly description?: string | undefined
     readonly state?: PrdIssue["state"] | undefined
@@ -114,6 +115,7 @@ export class PrdIssue extends Schema.Class<PrdIssue>("PrdIssue")({
   }): PrdIssue {
     return new PrdIssue({
       ...this,
+      id: options.id ?? this.id,
       title: options.title ?? this.title,
       description: options.description ?? this.description,
       state: options.state ?? this.state,

package/src/shared/runtime.ts

@@ -1,9 +0,0 @@
-import { Layer } from "effect"
-import { Atom } from "effect/unstable/reactivity"
-import { TracingLayer } from "../Tracing.ts"
-
-export const lalphMemoMap = Layer.makeMemoMapUnsafe()
-
-export const atomRuntime = Atom.context({ memoMap: lalphMemoMap })
-
-atomRuntime.addGlobalLayer(TracingLayer)