lalph 0.3.97 → 0.3.98

package/dist/cli.mjs

@@ -31501,6 +31501,42 @@ const takeUntil = /* @__PURE__ */ dual((args) => isStream(args[0]), (self, predi
 	});
 })));
 /**
+* Effectful predicate version of `takeUntil`.
+*
+* @example
+* ```ts
+* import { Console, Effect, Stream } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const result = yield* Stream.range(1, 5).pipe(
+*     Stream.takeUntilEffect((n) => Effect.succeed(n % 3 === 0)),
+*     Stream.runCollect
+*   )
+*   yield* Console.log(result)
+* })
+*
+* Effect.runPromise(program)
+* // Output: [ 1, 2, 3 ]
+* ```
+*
+* @since 2.0.0
+* @category Filtering
+*/
+const takeUntilEffect = /* @__PURE__ */ dual((args) => isStream(args[0]), (self, predicate, options) => transformPull(self, (pull, _scope) => sync(() => {
+	let i = 0;
+	let done$6 = false;
+	return gen(function* () {
+		if (done$6) return yield* done();
+		const chunk = yield* pull;
+		for (let j = 0; j < chunk.length; j++) if (yield* predicate(chunk[j], i++)) {
+			done$6 = true;
+			const arr = chunk.slice(0, options?.excludeLast ? j : j + 1);
+			return isReadonlyArrayNonEmpty(arr) ? arr : yield* done();
+		}
+		return chunk;
+	});
+})));
+/**
 * Drops the first `n` elements from this stream.
 *
 * @example
@@ -240005,11 +240041,6 @@ var CurrentIssueSource = class CurrentIssueSource extends Service$1()("lalph/Cur
 };
 const refreshSchedule = exponential(100, 1.5).pipe(either(spaced("30 seconds")));
 const getCurrentIssues = (projectId) => IssueSource.use((s) => pipe$1(s.ref(projectId), flatMap$4(get$5)));
-const checkForWork = fnUntraced(function* (project) {
-	if (project.gitFlow === "ralph") return;
-	const { issues } = yield* getCurrentIssues(project.id);
-	if (!issues.some((issue) => issue.state === "todo" && issue.blockedBy.length === 0)) return yield* new NoMoreWork({});
-});
 const resetInProgress = gen(function* () {
 	const source = yield* IssueSource;
 	const projectId = yield* CurrentProjectId;
@@ -240025,9 +240056,6 @@ const resetInProgress = gen(function* () {
 		discard: true
 	});
 });
-var NoMoreWork = class extends ErrorClass("lalph/Prd/NoMoreWork")({ _tag: tag("NoMoreWork") }) {
-	message = "No more work to be done!";
-};
 //#endregion
 //#region src/PromptGen.ts
 var PromptGen = class extends Service$1()("lalph/PromptGen", { make: gen(function* () {
@@ -241697,6 +241725,7 @@ const runProject = fnUntraced(function* (options) {
 	const iterationsDisplay = isFinite ? options.iterations : "unlimited";
 	const semaphore = makeUnsafe$9(options.project.concurrency);
 	const fibers = yield* make$56();
+	const issuesRef = yield* (yield* IssueSource).ref(options.project.id);
 	let executionMode;
 	if (options.project.gitFlow === "ralph") {
 		if (!options.project.ralphSpec) return yield* new RalphSpecMissing({ projectId: options.project.id });
@@ -241733,20 +241762,22 @@ const runProject = fnUntraced(function* (options) {
 			research: options.project.researchAgent
 		});
 	};
-	const handleNoMoreWork = (currentIteration, setIterations) => {
-		if (executionMode._tag === "ralph") return void_$2;
-		if (isFinite) {
-			setIterations(currentIteration);
-			return log$1(`No more work to process, ending after ${currentIteration} iteration(s).`);
-		}
-		return andThen(size$3(fibers) <= 1 ? log$1("No more work to process, waiting 30 seconds...") : void_$2, sleep(seconds(30)));
-	};
 	yield* resetInProgress.pipe(withSpan$1("Main.resetInProgress"));
 	yield* log$1(`Executing ${iterationsDisplay} iteration(s) with concurrency ${options.project.concurrency}`);
 	let iterations = options.iterations;
 	let iteration = 0;
 	let quit = false;
 	yield* mount(activeWorkerLoggingAtom);
+	const waitForWork = executionMode._tag === "ralph" ? void_$2 : changes(issuesRef).pipe(takeUntilEffect(fnUntraced(function* ({ issues }) {
+		if (issues.some((issue) => issue.state === "todo" && issue.blockedBy.length === 0)) return true;
+		if (isFinite) {
+			quit = true;
+			yield* log$1(`No more work to process, ending after ${iteration} iteration(s).`);
+			return yield* interrupt$1;
+		}
+		if (size$3(fibers) <= 1) yield* log$1("No more work to process");
+		return false;
+	})), runDrain);
 	while (true) {
 		yield* semaphore.take(1);
 		if (quit || isFinite && iteration >= iterations) break;
@@ -241754,17 +241785,12 @@ const runProject = fnUntraced(function* (options) {
 		const startedDeferred = yield* make$87();
 		let ralphDone = false;
 		const gitFlowLayer = resolveGitFlowLayer();
-		const fiber = yield* checkForWork(options.project).pipe(andThen(resolveRunEffect(startedDeferred).pipe(provide$1(gitFlowLayer, { local: true }), withWorkerState(options.project.id))), catchTags$1({
+		const fiber = yield* waitForWork.pipe(andThen(resolveRunEffect(startedDeferred).pipe(provide$1(gitFlowLayer, { local: true }), withWorkerState(options.project.id))), catchTags$1({
 			ChosenTaskNotFound(_error) {
 				if (executionMode._tag !== "ralph") return void_$2;
 				ralphDone = true;
 				return log$1(`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 void_$2;
@@ -242133,7 +242159,7 @@ const commandEdit = make$60("edit").pipe(withDescription("Open the selected proj
 const commandSource = make$60("source").pipe(withDescription("Select the issue source to use (e.g. GitHub Issues or Linear). This applies to all projects."), withHandler(() => selectIssueSource), provide(Settings.layer));
 //#endregion
 //#region package.json
-var version = "0.3.97";
+var version = "0.3.98";
 //#endregion
 //#region src/Tracing.ts
 const TracingLayer = unwrap$3(gen(function* () {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lalph",
   "type": "module",
-  "version": "0.3.97",
+  "version": "0.3.98",
   "publishConfig": {
     "access": "public"
   },

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