lalph 0.3.97 → 0.3.99

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lalph",
   "type": "module",
-  "version": "0.3.97",
+  "version": "0.3.99",
   "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.20260321.1",
-    "clanka": "^0.2.26",
+    "@typescript/native-preview": "7.0.0-dev.20260322.1",
+    "clanka": "^0.2.29",
     "concurrently": "^9.2.1",
     "effect": "4.0.0-beta.36",
     "husky": "^9.1.7",
@@ -55,7 +55,7 @@
     "prettier": "^3.8.1",
     "tsdown": "^0.21.4",
     "typescript": "^5.9.3",
-    "yaml": "^2.8.2"
+    "yaml": "^2.8.3"
   },
   "lint-staged": {
     "*.{ts,tsx}": [

package/src/Agents/planner.ts

@@ -3,6 +3,7 @@ import { PromptGen } from "../PromptGen.ts"
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
 import { Worktree } from "../Worktree.ts"
 import type { CliAgentPreset } from "../domain/CliAgentPreset.ts"
+import { runClankaPlan } from "../Clanka.ts"
 
 export const agentPlanner = Effect.fnUntraced(function* (options: {
   readonly plan: string
@@ -16,6 +17,15 @@ export const agentPlanner = Effect.fnUntraced(function* (options: {
   const promptGen = yield* PromptGen
   const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
 
+  if (options.preset.cliAgent.id === "clanka") {
+    yield* runClankaPlan({
+      directory: worktree.directory,
+      model: options.preset.extraArgs.join(" "),
+      prompt: promptGen.planPrompt(options),
+    })
+    return
+  }
+
   yield* pipe(
     options.preset.cliAgent.commandPlan({
       prompt: promptGen.planPrompt(options),

package/src/Clanka.ts

@@ -12,6 +12,7 @@ import {
   Stdio,
   Stream,
 } from "effect"
+import { Prompt as CliPrompt } from "effect/unstable/cli"
 import { TaskChooseTools, TaskTools, TaskToolsHandlers } from "./TaskTools.ts"
 import { layerClankaModel, ModelServices } from "./ClankaModels.ts"
 import { withStallTimeout } from "./shared/stream.ts"
@@ -136,3 +137,52 @@ export const runClanka = Effect.fnUntraced(
     ),
   Effect.provide([ModelServices, TaskToolsHandlers]),
 )
+
+export const runClankaPlan = Effect.fnUntraced(
+  function* (options: {
+    readonly directory: string
+    readonly model: string
+    readonly prompt: Prompt.RawInput
+  }) {
+    const stdio = yield* Stdio.Stdio
+    const agent = yield* Agent.Agent
+    let nextPrompt = options.prompt
+
+    while (true) {
+      const output = yield* agent.send({
+        prompt: nextPrompt,
+        system: `ONLY call taskComplete by itself. NEVER call taskComplete alongside other functions, to ensure you first read output before deciding a task is done.`,
+      })
+
+      yield* output.pipe(
+        OutputFormatter.pretty({
+          outputTruncation: 20,
+        }),
+        Stream.run(stdio.stdout()),
+      )
+
+      console.log("")
+      nextPrompt = yield* CliPrompt.text({
+        message: ">",
+      })
+    }
+  },
+  Effect.scoped,
+  (effect, options) =>
+    Effect.provide(
+      effect,
+      Agent.layerLocal({
+        directory: options.directory,
+      }).pipe(
+        Layer.provide(SemanticSearchLayer),
+        Layer.merge(layerClankaModel(options.model)),
+      ),
+      { local: true },
+    ),
+  Effect.provide([
+    ModelServices,
+    TaskToolsHandlers,
+    Agent.ConversationMode.layer(true),
+  ]),
+  Effect.ignore(),
+)

package/src/CurrentIssueSource.ts

@@ -17,7 +17,7 @@ import { GithubIssueSource } from "./Github.ts"
 import { IssuesChange, IssueSource } from "./IssueSource.ts"
 import { PlatformServices } from "./shared/platform.ts"
 import type { PrdIssue } from "./domain/PrdIssue.ts"
-import type { Project, ProjectId } from "./domain/Project.ts"
+import type { ProjectId } from "./domain/Project.ts"
 import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner"
 
 const issueSources: ReadonlyArray<typeof CurrentIssueSource.Service> = [
@@ -202,17 +202,6 @@ const getCurrentIssues = (projectId: ProjectId) =>
     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 hasIncomplete = issues.some(
-    (issue) => issue.state === "todo" && issue.blockedBy.length === 0,
-  )
-  if (!hasIncomplete) {
-    return yield* new NoMoreWork({})
-  }
-})
-
 export const resetInProgress = Effect.gen(function* () {
   const source = yield* IssueSource
   const projectId = yield* CurrentProjectId
@@ -233,11 +222,3 @@ export const resetInProgress = Effect.gen(function* () {
     { concurrency: 5, discard: true },
   )
 })
-
-export class NoMoreWork extends Schema.ErrorClass<NoMoreWork>(
-  "lalph/Prd/NoMoreWork",
-)({
-  _tag: Schema.tag("NoMoreWork"),
-}) {
-  readonly message = "No more work to be done!"
-}

package/src/commands/root.ts

@@ -24,11 +24,7 @@ import { Prd } from "../Prd.ts"
 import { Worktree } from "../Worktree.ts"
 import { Flag, Command, Prompt } from "effect/unstable/cli"
 import { IssueSource, IssueSourceError } from "../IssueSource.ts"
-import {
-  checkForWork,
-  CurrentIssueSource,
-  resetInProgress,
-} from "../CurrentIssueSource.ts"
+import { CurrentIssueSource, resetInProgress } from "../CurrentIssueSource.ts"
 import { GithubCli } from "../Github/Cli.ts"
 import { agentWorker } from "../Agents/worker.ts"
 import { agentChooser, ChosenTaskNotFound } from "../Agents/chooser.ts"
@@ -542,6 +538,8 @@ const runProject = Effect.fnUntraced(
     const iterationsDisplay = isFinite ? options.iterations : "unlimited"
     const semaphore = Semaphore.makeUnsafe(options.project.concurrency)
     const fibers = yield* FiberSet.make()
+    const source = yield* IssueSource
+    const issuesRef = yield* source.ref(options.project.id)
 
     let executionMode: ProjectExecutionMode
     if (options.project.gitFlow === "ralph") {
@@ -594,28 +592,6 @@ const runProject = Effect.fnUntraced(
       })
     }
 
-    const handleNoMoreWork = (
-      currentIteration: number,
-      setIterations: (iterations: number) => void,
-    ) => {
-      if (executionMode._tag === "ralph") {
-        return Effect.void
-      }
-      if (isFinite) {
-        // If we have a finite number of iterations, we exit when no more
-        // work is found
-        setIterations(currentIteration)
-        return Effect.log(
-          `No more work to process, ending after ${currentIteration} iteration(s).`,
-        )
-      }
-      const log =
-        Iterable.size(fibers) <= 1
-          ? Effect.log("No more work to process, waiting 30 seconds...")
-          : Effect.void
-      return Effect.andThen(log, Effect.sleep(Duration.seconds(30)))
-    }
-
     yield* resetInProgress.pipe(Effect.withSpan("Main.resetInProgress"))
 
     yield* Effect.log(
@@ -628,6 +604,33 @@ const runProject = Effect.fnUntraced(
 
     yield* Atom.mount(activeWorkerLoggingAtom)
 
+    const waitForWork =
+      executionMode._tag === "ralph"
+        ? Effect.void
+        : SubscriptionRef.changes(issuesRef).pipe(
+            Stream.takeUntilEffect(
+              Effect.fnUntraced(function* ({ issues }) {
+                const hasIncomplete = issues.some(
+                  (issue) =>
+                    issue.state === "todo" && issue.blockedBy.length === 0,
+                )
+                if (hasIncomplete) return true
+                if (isFinite) {
+                  quit = true
+                  yield* Effect.log(
+                    `No more work to process, ending after ${iteration} iteration(s).`,
+                  )
+                  return yield* Effect.interrupt
+                }
+                if (Iterable.size(fibers) <= 1) {
+                  yield* Effect.log("No more work to process")
+                }
+                return false
+              }),
+            ),
+            Stream.runDrain,
+          )
+
     while (true) {
       yield* semaphore.take(1)
       if (quit || (isFinite && iteration >= iterations)) {
@@ -640,7 +643,7 @@ const runProject = Effect.fnUntraced(
       let ralphDone = false
 
       const gitFlowLayer = resolveGitFlowLayer()
-      const fiber = yield* checkForWork(options.project).pipe(
+      const fiber = yield* waitForWork.pipe(
         Effect.andThen(
           resolveRunEffect(startedDeferred).pipe(
             Effect.provide(gitFlowLayer, { local: true }),
@@ -657,11 +660,6 @@ const runProject = Effect.fnUntraced(
               `No more work to process for Ralph, ending after ${currentIteration + 1} iteration(s).`,
             )
           },
-          NoMoreWork(_error) {
-            return handleNoMoreWork(currentIteration, (newIterations) => {
-              iterations = newIterations
-            })
-          },
           QuitError(_error) {
             quit = true
             return Effect.void

package/src/domain/CliAgent.ts

@@ -33,7 +33,7 @@ const clanka = new CliAgent({
   name: "clanka",
   commandPlan: ({ prompt, prdFilePath, dangerous }) =>
     ChildProcess.make(
-      "opencode",
+      "clanka",
       [
         "--prompt",
         prdFilePath