lalph 0.3.46 → 0.3.48

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lalph",
   "type": "module",
-  "version": "0.3.46",
+  "version": "0.3.48",
   "publishConfig": {
     "access": "public"
   },
@@ -30,7 +30,7 @@
     "@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.16",
+    "clanka": "^0.0.21",
     "concurrently": "^9.2.1",
     "effect": "4.0.0-beta.30",
     "husky": "^9.1.7",

package/src/Agents/worker.ts

@@ -1,4 +1,4 @@
-import { Duration, Effect, Path, pipe } from "effect"
+import { Duration, Effect, Path, pipe, Stream } from "effect"
 import { ChildProcess } from "effect/unstable/process"
 import { Worktree } from "../Worktree.ts"
 import type { CliAgentPreset } from "../domain/CliAgentPreset.ts"
@@ -10,6 +10,7 @@ export const agentWorker = Effect.fnUntraced(function* (options: {
   readonly preset: CliAgentPreset
   readonly system?: string
   readonly prompt: string
+  readonly steer?: Stream.Stream<string>
 }) {
   const pathService = yield* Path.Path
   const worktree = yield* Worktree
@@ -22,6 +23,7 @@ export const agentWorker = Effect.fnUntraced(function* (options: {
       system: options.system,
       prompt: options.prompt,
       stallTimeout: options.stallTimeout,
+      steer: options.steer,
     })
     return ExitCode(0)
   }

package/src/Clanka.ts

@@ -1,47 +1,65 @@
 import { Agent, OutputFormatter } from "clanka"
-import { Duration, Effect, Stream } from "effect"
+import { Duration, Effect, Layer, Stdio, Stream } from "effect"
 import {
+  TaskChooseTools,
   TaskTools,
   TaskToolsHandlers,
   TaskToolsWithChoose,
 } 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 ClankaMuxerLayer = Layer.effectDiscard(
+  Effect.gen(function* () {
+    const muxer = yield* OutputFormatter.Muxer
+    const stdio = yield* Stdio.Stdio
+    yield* muxer.output.pipe(Stream.run(stdio.stdout()), Effect.forkScoped)
+  }),
+).pipe(Layer.provideMerge(OutputFormatter.layerMuxer(OutputFormatter.pretty)))
 
 export const runClanka = Effect.fnUntraced(
-  /** The working directory to run the agent in */
   function* (options: {
     readonly directory: string
     readonly model: string
     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
+    const muxer = yield* OutputFormatter.Muxer
+
     const agent = yield* Agent.make({
       ...options,
-      tools: options.withChoose
-        ? TaskToolsWithChoose
-        : (TaskTools as unknown as typeof TaskToolsWithChoose),
+      tools: (options.withChoose
+        ? TaskChooseTools
+        : TaskTools) as unknown as typeof TaskToolsWithChoose,
       subagentModel: clankaSubagent(models, options.model),
     }).pipe(Effect.provide(models.get(options.model)))
 
+    yield* muxer.add(agent.output)
+
     let stream = options.stallTimeout
       ? withStallTimeout(options.stallTimeout)(agent.output)
       : agent.output
 
-    return yield* stream.pipe(
-      OutputFormatter.pretty,
-      Stream.runForEachArray((out) => {
-        for (const item of out) {
-          process.stdout.write(item)
-        }
-        return Effect.void
-      }),
-      (_) => _ as Effect.Effect<void, AiError.AiError | RunnerStalled>,
+    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,
+      )
+    }
+
+    yield* stream.pipe(
+      Stream.runDrain,
+      Effect.catchTag("AgentFinished", () => Effect.void),
     )
   },
   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

@@ -90,12 +90,11 @@ Set \`githubPrNumber\` to the PR number if one exists, otherwise use \`null\`.
 
       const promptChooseClanka = (options: {
         readonly gitFlow: GitFlow["Service"]
-      }) => `Your job is to choose the next task to work on using "listEligibleTasks".
-**DO NOT** implement the task yet.
-
-The following instructions should be done without interaction or asking for permission.
-
-- Decide which single task to work on next from "listEligibleTasks". This should
+      }) => `- Use the "listEligibleTasks" function to view the list of tasks that you can start working on.
+  - **NO NOT PARSE THE yaml OUTPUT IN ANY WAY**
+  - **DO NOT** implement the task yet.
+  - **DO NOT** use the "delegate" function for any step in this workflow
+- After reading through the list of tasks, choose the task to work on. This should
   be the task YOU decide as the most important to work on next, not just the
   first task in the list.${
     options.gitFlow.requiresGithubPr

package/src/TaskTools.ts

@@ -1,8 +1,18 @@
-import { Deferred, Effect, Schema, ServiceMap, Struct } from "effect"
+import {
+  Deferred,
+  Effect,
+  MutableRef,
+  Option,
+  Random,
+  Schema,
+  ServiceMap,
+  Struct,
+} from "effect"
 import { Tool, Toolkit } from "effect/unstable/ai"
 import { PrdIssue } from "./domain/PrdIssue.ts"
 import { IssueSource } from "./IssueSource.ts"
 import { CurrentProjectId } from "./Settings.ts"
+import * as Yaml from "yaml"
 
 export class ChosenTaskDeferred extends ServiceMap.Reference(
   "lalph/TaskTools/ChosenTaskDeferred",
@@ -14,6 +24,17 @@ 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({
@@ -24,12 +45,20 @@ const TaskList = Schema.Array(
       "description",
       "state",
       "priority",
-      "estimate",
       "blockedBy",
     ]),
   }),
 )
 
+const toTaskListItem = (issue: PrdIssue) => ({
+  id: issue.id ?? "",
+  title: issue.title,
+  description: issue.description,
+  state: issue.state,
+  priority: issue.priority,
+  blockedBy: issue.blockedBy,
+})
+
 export class TaskTools extends Toolkit.make(
   Tool.make("listTasks", {
     description: "Returns the current list of tasks.",
@@ -43,7 +72,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,
@@ -69,22 +97,25 @@ export class TaskTools extends Toolkit.make(
   }),
 ) {}
 
+export class TaskChooseTools extends Toolkit.make(
+  Tool.make("chooseTask", {
+    description: "Choose the task to work on",
+    parameters: Schema.Struct({
+      taskId: Schema.String,
+      githubPrNumber: Schema.optional(Schema.Number),
+    }),
+  }),
+  Tool.make("listEligibleTasks", {
+    description:
+      "List tasks eligible for being chosen with chooseTask in yaml format.",
+    success: Schema.String,
+    dependencies: [CurrentProjectId],
+  }),
+) {}
+
 export class TaskToolsWithChoose extends Toolkit.merge(
   TaskTools,
-  Toolkit.make(
-    Tool.make("chooseTask", {
-      description: "Choose the task to work on",
-      parameters: Schema.Struct({
-        taskId: Schema.String,
-        githubPrNumber: Schema.optional(Schema.Number),
-      }),
-    }),
-    Tool.make("listEligibleTasks", {
-      description: "List tasks eligible for being chosen with chooseTask.",
-      success: TaskList,
-      dependencies: [CurrentProjectId],
-    }),
-  ),
+  TaskChooseTools,
 ) {}
 
 export const TaskToolsHandlers = TaskToolsWithChoose.toLayer(
@@ -96,31 +127,16 @@ export const TaskToolsHandlers = TaskToolsWithChoose.toLayer(
         yield* Effect.log(`Calling "listTasks"`)
         const projectId = yield* CurrentProjectId
         const tasks = yield* source.issues(projectId)
-        return tasks.map((issue) => ({
-          id: issue.id ?? "",
-          title: issue.title,
-          description: issue.description,
-          state: issue.state,
-          priority: issue.priority,
-          estimate: issue.estimate,
-          blockedBy: issue.blockedBy,
-        }))
+        return tasks.map(toTaskListItem)
       }, 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,
-            estimate: issue.estimate,
-            blockedBy: issue.blockedBy,
-          }))
+        const tasks = (yield* source.issues(projectId))
+          .filter((t) => t.state === "todo" && t.blockedBy.length === 0)
+          .map(toTaskListItem)
+        const shuffled = yield* Random.shuffle(tasks)
+        return Yaml.stringify(shuffled, null, 2)
       }, Effect.orDie),
       chooseTask: Effect.fn("TaskTools.chooseTask")(function* (options) {
         yield* Effect.log(`Calling "chooseTask"`).pipe(
@@ -137,6 +153,7 @@ export const TaskToolsHandlers = TaskToolsWithChoose.toLayer(
           new PrdIssue({
             ...options,
             id: null,
+            estimate: null,
             autoMerge: false,
           }),
         )
@@ -147,6 +164,7 @@ 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/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/tasks.ts

@@ -11,6 +11,7 @@ import { selectCliAgentPreset } from "../../Presets.ts"
 import { CurrentIssueSource } from "../../CurrentIssueSource.ts"
 import type { CliAgentPreset } from "../../domain/CliAgentPreset.ts"
 import { ClankaModels } from "../../ClankaModels.ts"
+import { ClankaMuxerLayer } from "../../Clanka.ts"
 
 const specificationPath = Argument.path("spec", {
   pathType: "file",
@@ -72,6 +73,7 @@ const generateTasks = Effect.fnUntraced(
   },
   Effect.provide([
     ClankaModels.layer,
+    ClankaMuxerLayer,
     Settings.layer,
     PromptGen.layer,
     Prd.layerProvided.pipe(Layer.provideMerge(layerProjectIdPrompt)),

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"
@@ -16,6 +25,7 @@ import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
 import { parseBranch } from "../shared/git.ts"
 import type { CliAgentPreset } from "../domain/CliAgentPreset.ts"
 import { ClankaModels } from "../ClankaModels.ts"
+import { ClankaMuxerLayer } from "../Clanka.ts"
 
 const dangerous = Flag.boolean("dangerous").pipe(
   Flag.withAlias("d"),
@@ -48,41 +58,55 @@ 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,
+            ClankaMuxerLayer,
+          ]),
+        )
+      },
+      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,10 @@ 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"
+import { CurrentTaskRef } from "../TaskTools.ts"
+import type { OutputFormatter } from "clanka"
+import { ClankaMuxerLayer } from "../Clanka.ts"
 
 // Main iteration run logic
 
@@ -84,6 +91,7 @@ const run = Effect.fnUntraced(
     | Prd
     | Worktree
     | ClankaModels
+    | OutputFormatter.Muxer
     | Scope.Scope
   > {
     const projectId = yield* CurrentProjectId
@@ -217,11 +225,26 @@ const run = Effect.fnUntraced(
             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,
-      }).pipe(catchStallInReview, Effect.withSpan("Main.agentWorker"))
+        steer,
+      }).pipe(
+        Effect.provideService(CurrentTaskRef, issueRef),
+        catchStallInReview,
+        Effect.withSpan("Main.agentWorker"),
+      )
       yield* Effect.log(`Agent exited with code: ${exitCode}`)
 
       // 3. Review task
@@ -469,6 +492,7 @@ export const commandRoot = Command.make("lalph", {
       Effect.scoped,
       Effect.provide([
         ClankaModels.layer,
+        ClankaMuxerLayer,
         PromptGen.layer,
         GithubCli.layer,
         Settings.layer,
@@ -515,3 +539,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,
+    })
+  }
 }