lalph 0.3.45 → 0.3.47

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lalph",
   "type": "module",
-  "version": "0.3.45",
+  "version": "0.3.47",
   "publishConfig": {
     "access": "public"
   },
@@ -22,13 +22,15 @@
   "devDependencies": {
     "@changesets/changelog-github": "^0.6.0",
     "@changesets/cli": "^2.30.0",
+    "@effect/ai-openai": "4.0.0-beta.30",
+    "@effect/ai-openai-compat": "4.0.0-beta.30",
     "@effect/language-service": "^0.79.0",
     "@effect/platform-node": "4.0.0-beta.30",
     "@linear/sdk": "^77.0.0",
     "@octokit/plugin-rest-endpoint-methods": "^17.0.0",
     "@octokit/types": "^16.0.0",
     "@typescript/native-preview": "7.0.0-dev.20260310.1",
-    "clanka": "^0.0.15",
+    "clanka": "^0.0.17",
     "concurrently": "^9.2.1",
     "effect": "4.0.0-beta.30",
     "husky": "^9.1.7",

package/src/Agents/reviewer.ts

@@ -40,6 +40,7 @@ export const agentReviewer = Effect.fnUntraced(function* (options: {
           promptGen.promptReviewCustom({
             prompt,
             specsDirectory: options.specsDirectory,
+            removePrdNotes: true,
           }),
       }),
       stallTimeout: options.stallTimeout,
@@ -59,6 +60,7 @@ export const agentReviewer = Effect.fnUntraced(function* (options: {
           promptGen.promptReviewCustom({
             prompt,
             specsDirectory: options.specsDirectory,
+            removePrdNotes: false,
           }),
       }),
       prdFilePath: pathService.join(".lalph", "prd.yml"),

package/src/Agents/worker.ts

@@ -1,15 +1,18 @@
-import { Duration, Effect, Path, pipe } from "effect"
+import { Duration, Effect, identity, Path, pipe, Stream } from "effect"
 import { ChildProcess } from "effect/unstable/process"
 import { Worktree } from "../Worktree.ts"
 import type { CliAgentPreset } from "../domain/CliAgentPreset.ts"
 import { runClanka } from "../Clanka.ts"
 import { ExitCode } from "effect/unstable/process/ChildProcessSpawner"
+import { CurrentTaskRef } from "../TaskTools.ts"
 
 export const agentWorker = Effect.fnUntraced(function* (options: {
   readonly stallTimeout: Duration.Duration
   readonly preset: CliAgentPreset
   readonly system?: string
   readonly prompt: string
+  readonly steer?: Stream.Stream<string>
+  readonly taskRef?: CurrentTaskRef["Service"]
 }) {
   const pathService = yield* Path.Path
   const worktree = yield* Worktree
@@ -22,7 +25,12 @@ export const agentWorker = Effect.fnUntraced(function* (options: {
       system: options.system,
       prompt: options.prompt,
       stallTimeout: options.stallTimeout,
-    })
+      steer: options.steer,
+    }).pipe(
+      options.taskRef
+        ? Effect.provideService(CurrentTaskRef, options.taskRef)
+        : identity,
+    )
     return ExitCode(0)
   }
 

package/src/Clanka.ts

@@ -7,8 +7,6 @@ import {
 } from "./TaskTools.ts"
 import { ClankaModels, clankaSubagent } from "./ClankaModels.ts"
 import { withStallTimeout } from "./shared/stream.ts"
-import type { AiError } from "effect/unstable/ai"
-import type { RunnerStalled } from "./domain/Errors.ts"
 
 export const runClanka = Effect.fnUntraced(
   /** The working directory to run the agent in */
@@ -18,6 +16,7 @@ export const runClanka = Effect.fnUntraced(
     readonly prompt: string
     readonly system?: string | undefined
     readonly stallTimeout?: Duration.Input | undefined
+    readonly steer?: Stream.Stream<string> | undefined
     readonly withChoose?: boolean | undefined
   }) {
     const models = yield* ClankaModels
@@ -33,6 +32,19 @@ export const runClanka = Effect.fnUntraced(
       ? withStallTimeout(options.stallTimeout)(agent.output)
       : agent.output
 
+    if (options.steer) {
+      yield* options.steer.pipe(
+        Stream.switchMap(
+          Effect.fnUntraced(function* (message) {
+            yield* Effect.log(`Received steer message: ${message}`)
+            yield* agent.steer(message)
+          }, Stream.fromEffectDrain),
+        ),
+        Stream.runDrain,
+        Effect.forkScoped,
+      )
+    }
+
     return yield* stream.pipe(
       OutputFormatter.pretty,
       Stream.runForEachArray((out) => {
@@ -41,7 +53,6 @@ export const runClanka = Effect.fnUntraced(
         }
         return Effect.void
       }),
-      (_) => _ as Effect.Effect<void, AiError.AiError | RunnerStalled>,
     )
   },
   Effect.scoped,

package/src/Editor.ts

@@ -57,7 +57,18 @@ export class Editor extends ServiceMap.Service<Editor>()("lalph/Editor", {
       Effect.option,
     )
 
-    return { edit, editTemp } as const
+    const saveTemp = Effect.fnUntraced(function* (
+      content: string,
+      options: { suffix?: string },
+    ) {
+      const file = yield* fs.makeTempFile({
+        suffix: options.suffix ?? ".txt",
+      })
+      yield* fs.writeFileString(file, content)
+      return file
+    })
+
+    return { edit, editTemp, saveTemp } as const
   }),
 }) {
   static layer = Layer.effect(this, this.make).pipe(

package/src/PromptGen.ts

@@ -285,7 +285,11 @@ ${options.prompt}`
       const promptReviewCustom = (options: {
         readonly prompt: string
         readonly specsDirectory: string
-      }) => `${options.prompt}
+        readonly removePrdNotes: boolean
+      }) =>
+        options.removePrdNotes
+          ? options.prompt
+          : `${options.prompt}
 
 ${prdNotes(options)}`
 

package/src/TaskTools.ts

@@ -1,4 +1,12 @@
-import { Deferred, Effect, Schema, ServiceMap, Struct } from "effect"
+import {
+  Deferred,
+  Effect,
+  MutableRef,
+  Option,
+  Schema,
+  ServiceMap,
+  Struct,
+} from "effect"
 import { Tool, Toolkit } from "effect/unstable/ai"
 import { PrdIssue } from "./domain/PrdIssue.ts"
 import { IssueSource } from "./IssueSource.ts"
@@ -14,24 +22,36 @@ 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 TaskList = Schema.Array(
+  Schema.Struct({
+    id: Schema.String.annotate({
+      documentation: "The unique identifier of the task.",
+    }),
+    ...Struct.pick(PrdIssue.fields, [
+      "title",
+      "description",
+      "state",
+      "priority",
+      "blockedBy",
+    ]),
+  }),
+)
+
 export class TaskTools extends Toolkit.make(
   Tool.make("listTasks", {
     description: "Returns the current list of tasks.",
-    success: Schema.Array(
-      Schema.Struct({
-        id: Schema.String.annotate({
-          documentation: "The unique identifier of the task.",
-        }),
-        ...Struct.pick(PrdIssue.fields, [
-          "title",
-          "description",
-          "state",
-          "priority",
-          "estimate",
-          "blockedBy",
-        ]),
-      }),
-    ),
+    success: TaskList,
     dependencies: [CurrentProjectId],
   }),
   Tool.make("createTask", {
@@ -41,7 +61,6 @@ export class TaskTools extends Toolkit.make(
       description: PrdIssue.fields.description,
       state: PrdIssue.fields.state,
       priority: PrdIssue.fields.priority,
-      estimate: PrdIssue.fields.estimate,
       blockedBy: PrdIssue.fields.blockedBy,
     }),
     success: Schema.String,
@@ -58,13 +77,13 @@ export class TaskTools extends Toolkit.make(
     }),
     dependencies: [CurrentProjectId],
   }),
-  // Tool.make("removeTask", {
-  //   description: "Remove a task by it's id.",
-  //   parameters: Schema.String.annotate({
-  //     identifier: "taskId",
-  //   }),
-  //   dependencies: [CurrentProjectId],
-  // }),
+  Tool.make("removeTask", {
+    description: "Remove a task by it's id.",
+    parameters: Schema.String.annotate({
+      identifier: "taskId",
+    }),
+    dependencies: [CurrentProjectId],
+  }),
 ) {}
 
 export class TaskToolsWithChoose extends Toolkit.merge(
@@ -77,6 +96,11 @@ export class TaskToolsWithChoose extends Toolkit.merge(
         githubPrNumber: Schema.optional(Schema.Number),
       }),
     }),
+    Tool.make("listEligibleTasks", {
+      description: "List tasks eligible for being chosen with chooseTask.",
+      success: TaskList,
+      dependencies: [CurrentProjectId],
+    }),
   ),
 ) {}
 
@@ -95,10 +119,24 @@ export const TaskToolsHandlers = TaskToolsWithChoose.toLayer(
           description: issue.description,
           state: issue.state,
           priority: issue.priority,
-          estimate: issue.estimate,
           blockedBy: issue.blockedBy,
         }))
       }, Effect.orDie),
+      listEligibleTasks: Effect.fn("TaskTools.listEligibleTasks")(function* () {
+        yield* Effect.log(`Calling "listEligibleTasks"`)
+        const projectId = yield* CurrentProjectId
+        const tasks = yield* source.issues(projectId)
+        return tasks
+          .filter((t) => t.blockedBy.length === 0 && t.state === "todo")
+          .map((issue) => ({
+            id: issue.id ?? "",
+            title: issue.title,
+            description: issue.description,
+            state: issue.state,
+            priority: issue.priority,
+            blockedBy: issue.blockedBy,
+          }))
+      }, Effect.orDie),
       chooseTask: Effect.fn("TaskTools.chooseTask")(function* (options) {
         yield* Effect.log(`Calling "chooseTask"`).pipe(
           Effect.annotateLogs(options),
@@ -114,6 +152,7 @@ export const TaskToolsHandlers = TaskToolsWithChoose.toLayer(
           new PrdIssue({
             ...options,
             id: null,
+            estimate: null,
             autoMerge: false,
           }),
         )
@@ -124,19 +163,20 @@ 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,
           ...options,
         })
       }, Effect.orDie),
-      // removeTask: Effect.fn("TaskTools.removeTask")(function* (taskId) {
-      //   yield* Effect.log(`Calling "removeTask"`).pipe(
-      //     Effect.annotateLogs({ taskId }),
-      //   )
-      //   const projectId = yield* CurrentProjectId
-      //   yield* source.cancelIssue(projectId, taskId)
-      // }, Effect.orDie),
+      removeTask: Effect.fn("TaskTools.removeTask")(function* (taskId) {
+        yield* Effect.log(`Calling "removeTask"`).pipe(
+          Effect.annotateLogs({ taskId }),
+        )
+        const projectId = yield* CurrentProjectId
+        yield* source.cancelIssue(projectId, taskId)
+      }, Effect.orDie),
     })
   }),
 )

package/src/commands/issue.ts

@@ -1,6 +1,6 @@
 import { Command } from "effect/unstable/cli"
 import { CurrentIssueSource } from "../CurrentIssueSource.ts"
-import { Effect, flow, Option, Schema } from "effect"
+import { Effect, Exit, flow, Option, pipe, Schema } from "effect"
 import { IssueSource } from "../IssueSource.ts"
 import { PrdIssue } from "../domain/PrdIssue.ts"
 import * as Yaml from "yaml"
@@ -40,8 +40,18 @@ const handler = flow(
       if (Option.isNone(content)) {
         return
       }
+      const contentValue = content.value.trim()
 
-      const lines = content.value.split("\n")
+      yield* Effect.addFinalizer((exit) => {
+        if (Exit.isSuccess(exit)) return Effect.void
+        return pipe(
+          editor.saveTemp(contentValue, { suffix: ".md" }),
+          Effect.flatMap((file) => Effect.log(`Saved your issue to: ${file}`)),
+          Effect.ignore,
+        )
+      })
+
+      const lines = contentValue.split("\n")
       const yamlLines: string[] = []
       let descriptionStartIndex = 0
       for (let i = 0; i < lines.length; i++) {
@@ -81,7 +91,7 @@ const handler = flow(
         console.log(`Created issue with ID: ${created.id}`)
         console.log(`URL: ${created.url}`)
       }).pipe(Effect.provide([layerProjectIdPrompt, CurrentIssueSource.layer]))
-    }),
+    }, Effect.scoped),
   ),
   Command.provide(Editor.layer),
 )

package/src/commands/plan.ts

@@ -1,4 +1,13 @@
-import { Data, Effect, FileSystem, Option, Path, pipe, Schema } from "effect"
+import {
+  Data,
+  Effect,
+  Exit,
+  FileSystem,
+  Option,
+  Path,
+  pipe,
+  Schema,
+} from "effect"
 import { PromptGen } from "../PromptGen.ts"
 import { Prd } from "../Prd.ts"
 import { Worktree } from "../Worktree.ts"
@@ -48,41 +57,54 @@ export const commandPlan = Command.make("plan", {
     "Draft a plan in your editor (or use --file); then generate a specification under --specs and create PRD tasks from it. Use --new to create a project first, and --dangerous to skip permission prompts during spec generation.",
   ),
   Command.withHandler(
-    Effect.fnUntraced(function* ({ dangerous, withNewProject, file }) {
-      const editor = yield* Editor
-      const fs = yield* FileSystem.FileSystem
-
-      const thePlan = yield* Effect.matchEffect(file.asEffect(), {
-        onFailure: () => editor.editTemp({ suffix: ".md" }),
-        onSuccess: (path) => fs.readFileString(path).pipe(Effect.asSome),
-      })
-
-      if (Option.isNone(thePlan)) return
-
-      // We nest this effect, so we can launch the editor first as fast as
-      // possible
-      yield* Effect.gen(function* () {
-        const project = withNewProject
-          ? yield* addOrUpdateProject()
-          : yield* selectProject
-        const { specsDirectory } = yield* commandRoot
-        const preset = yield* selectCliAgentPreset
-
-        yield* plan({
-          plan: thePlan.value,
-          specsDirectory,
-          targetBranch: project.targetBranch,
-          dangerous,
-          preset,
-        }).pipe(Effect.provideService(CurrentProjectId, project.id))
-      }).pipe(
-        Effect.provide([
-          Settings.layer,
-          CurrentIssueSource.layer,
-          ClankaModels.layer,
-        ]),
-      )
-    }, Effect.provide(Editor.layer)),
+    Effect.fnUntraced(
+      function* ({ dangerous, withNewProject, file }) {
+        const editor = yield* Editor
+        const fs = yield* FileSystem.FileSystem
+
+        const thePlan = yield* Effect.matchEffect(file.asEffect(), {
+          onFailure: () => editor.editTemp({ suffix: ".md" }),
+          onSuccess: (path) => fs.readFileString(path).pipe(Effect.asSome),
+        })
+
+        if (Option.isNone(thePlan)) return
+
+        yield* Effect.addFinalizer((exit) => {
+          if (Exit.isSuccess(exit)) return Effect.void
+          return pipe(
+            editor.saveTemp(thePlan.value, { suffix: ".md" }),
+            Effect.flatMap((file) => Effect.log(`Saved your plan to: ${file}`)),
+            Effect.ignore,
+          )
+        })
+
+        // We nest this effect, so we can launch the editor first as fast as
+        // possible
+        yield* Effect.gen(function* () {
+          const project = withNewProject
+            ? yield* addOrUpdateProject()
+            : yield* selectProject
+          const { specsDirectory } = yield* commandRoot
+          const preset = yield* selectCliAgentPreset
+
+          yield* plan({
+            plan: thePlan.value,
+            specsDirectory,
+            targetBranch: project.targetBranch,
+            dangerous,
+            preset,
+          }).pipe(Effect.provideService(CurrentProjectId, project.id))
+        }).pipe(
+          Effect.provide([
+            Settings.layer,
+            CurrentIssueSource.layer,
+            ClankaModels.layer,
+          ]),
+        )
+      },
+      Effect.scoped,
+      Effect.provide(Editor.layer),
+    ),
   ),
   Command.withSubcommands([commandPlanTasks]),
 )

package/src/commands/root.ts

@@ -6,9 +6,12 @@ import {
   FiberSet,
   FileSystem,
   Iterable,
+  MutableRef,
   Option,
   Path,
   PlatformError,
+  Result,
+  Schedule,
   Schema,
   Scope,
   Semaphore,
@@ -48,6 +51,7 @@ import type { TimeoutError } from "effect/Cause"
 import type { ChildProcessSpawner } from "effect/unstable/process"
 import { ClankaModels } from "../ClankaModels.ts"
 import type { AiError } from "effect/unstable/ai/AiError"
+import type { PrdIssue } from "../domain/PrdIssue.ts"
 
 // Main iteration run logic
 
@@ -201,18 +205,37 @@ const run = Effect.fnUntraced(
       )
 
       const promptGen = yield* PromptGen
-      const instructions = promptGen.prompt({
-        specsDirectory: options.specsDirectory,
-        targetBranch: Option.getOrUndefined(options.targetBranch),
-        task: chosenTask.prd,
-        githubPrNumber: chosenTask.githubPrNumber ?? undefined,
-        gitFlow,
+      const instructions = taskPreset.cliAgent.command
+        ? promptGen.prompt({
+            specsDirectory: options.specsDirectory,
+            targetBranch: Option.getOrUndefined(options.targetBranch),
+            task: chosenTask.prd,
+            githubPrNumber: chosenTask.githubPrNumber ?? undefined,
+            gitFlow,
+          })
+        : promptGen.promptClanka({
+            specsDirectory: options.specsDirectory,
+            targetBranch: Option.getOrUndefined(options.targetBranch),
+            task: chosenTask.prd,
+            githubPrNumber: chosenTask.githubPrNumber ?? undefined,
+            gitFlow,
+          })
+
+      const issueRef = MutableRef.make(
+        chosenTask.prd.update({
+          state: "in-progress",
+        }),
+      )
+      const steer = yield* taskUpdateSteer({
+        issueId: taskId,
+        current: issueRef,
       })
 
       const exitCode = yield* agentWorker({
         stallTimeout: options.stallTimeout,
         preset: taskPreset,
         prompt: instructions,
+        steer,
       }).pipe(catchStallInReview, Effect.withSpan("Main.agentWorker"))
       yield* Effect.log(`Agent exited with code: ${exitCode}`)
 
@@ -507,3 +530,33 @@ const watchTaskState = Effect.fnUntraced(function* (options: {
     Effect.withSpan("Main.watchTaskState"),
   )
 })
+
+const taskUpdateSteer = Effect.fnUntraced(function* (options: {
+  readonly issueId: string
+  readonly current: MutableRef.MutableRef<PrdIssue>
+}) {
+  const registry = yield* AtomRegistry.AtomRegistry
+  const projectId = yield* CurrentProjectId
+
+  return AtomRegistry.toStreamResult(
+    registry,
+    currentIssuesAtom(projectId),
+  ).pipe(
+    Stream.drop(1),
+    Stream.retry(Schedule.forever),
+    Stream.orDie,
+    Stream.filterMap((issues) => {
+      const issue = issues.find((entry) => entry.id === options.issueId)
+      if (!issue) return Result.failVoid
+      if (!issue.isChangedComparedTo(options.current.current)) {
+        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}
+
+${issue.description}`)
+    }),
+  )
+})

package/src/domain/PrdIssue.ts

@@ -105,4 +105,19 @@ export class PrdIssue extends Schema.Class<PrdIssue>("PrdIssue")({
       autoMerge,
     })
   }
+
+  update(options: {
+    readonly title?: string | undefined
+    readonly description?: string | undefined
+    readonly state?: PrdIssue["state"] | undefined
+    readonly blockedBy?: ReadonlyArray<string> | undefined
+  }): PrdIssue {
+    return new PrdIssue({
+      ...this,
+      title: options.title ?? this.title,
+      description: options.description ?? this.description,
+      state: options.state ?? this.state,
+      blockedBy: options.blockedBy ?? this.blockedBy,
+    })
+  }
 }