lalph 0.1.77 → 0.1.78

package/dist/cli.mjs

@@ -135161,6 +135161,18 @@ var IssueSourceError = class extends ErrorClass("lalph/IssueSourceError")({
 const checkForWork = gen(function* () {
 	if (!(yield* (yield* IssueSource).issues).some((issue) => issue.state === "todo" && issue.blockedBy.length === 0)) return yield* new NoMoreWork({});
 });
+const resetInProgress = gen(function* () {
+	const source = yield* IssueSource;
+	const inProgress = (yield* source.issues).filter((issue) => issue.state === "in-progress" && issue.id !== null);
+	if (inProgress.length === 0) return;
+	yield* forEach$1(inProgress, (issue) => source.updateIssue({
+		issueId: issue.id,
+		state: "todo"
+	}), {
+		concurrency: 5,
+		discard: true
+	});
+});
 var NoMoreWork = class extends ErrorClass("lalph/Prd/NoMoreWork")({ _tag: tag("NoMoreWork") }) {
 	message = "No more work to be done!";
 };
@@ -135260,9 +135272,8 @@ const LinearIssueSource = effect(IssueSource, gen(function* () {
 		return isGreaterThanOrEqualTo$1(completed, threeDaysAgo);
 	}), mapEffect$1(fnUntraced(function* (issue) {
 		identifierMap.set(issue.identifier, issue.id);
-		const linearState = linear.states.find((s) => s.id === issue.stateId);
-		const blockedBy = yield* runCollect(linear.blockedBy(issue));
-		const state = linearStateToPrdState(linearState);
+		const state = linearStateToPrdState(linear.states.find((s) => s.id === issue.stateId));
+		const blockedBy = state === "todo" ? yield* runCollect(linear.blockedBy(issue)) : [];
 		return new PrdIssue({
 			id: issue.identifier,
 			title: issue.title,
@@ -135333,7 +135344,8 @@ const LinearIssueSource = effect(IssueSource, gen(function* () {
 		cancelIssue: fnUntraced(function* (issueId) {
 			const linearIssueId = identifierMap.get(issueId);
 			yield* linear.use((c) => c.updateIssue(linearIssueId, { stateId: canceledState.id }));
-		}, mapError$2((cause) => new IssueSourceError({ cause })))
+		}, mapError$2((cause) => new IssueSourceError({ cause }))),
+		ensureInProgress: () => void_$1
 	});
 })).pipe(provide$3(Linear.layer));
 const resetLinear = gen(function* () {
@@ -141802,6 +141814,17 @@ const GithubIssueSource = effect(IssueSource, gen(function* () {
 				issue_number: Number(issueId.slice(1)),
 				state: "closed"
 			});
+		}, mapError$2((cause) => new IssueSourceError({ cause }))),
+		ensureInProgress: fnUntraced(function* (issueId) {
+			const issueNumber = Number(issueId.slice(1));
+			yield* pipe(github.request((rest) => rest.issues.get({
+				owner: cli.owner,
+				repo: cli.repo,
+				issue_number: issueNumber
+			})), repeat({
+				until: (r) => hasLabel(r.data.labels, "in-progress"),
+				schedule: spaced("1 second")
+			}));
 		}, mapError$2((cause) => new IssueSourceError({ cause })))
 	});
 })).pipe(provide$3([Github.layer, GithubCli.layer]));
@@ -142365,7 +142388,9 @@ const commandRoot = make$27("lalph", {
 	const runConcurrency = Math.max(1, concurrency$1);
 	const semaphore = makeSemaphoreUnsafe(runConcurrency);
 	const fibers = yield* make$24();
+	yield* resetInProgress.pipe(provide$1(source));
 	yield* log$1(`Executing ${iterationsDisplay} iteration(s) with concurrency ${runConcurrency}`);
+	if (isSome(targetBranch$1)) yield* log$1(`Using target branch: ${targetBranch$1.value}`);
 	let iteration = 0;
 	let quit = false;
 	while (true) {
@@ -142407,6 +142432,7 @@ const run = fnUntraced(function* (options) {
 	const gh = yield* GithubCli;
 	const cliAgent = yield* getOrSelectCliAgent;
 	const prd = yield* Prd;
+	const source = yield* IssueSource;
 	const exec = (template, ...args$1) => make$21({ cwd: worktree.directory })(template, ...args$1).pipe(exitCode);
 	const execWithStallTimeout = fnUntraced(function* (command) {
 		let lastOutputAt = yield* now;
@@ -142443,8 +142469,15 @@ const run = fnUntraced(function* (options) {
 			onTimeout: () => fail$4(new RunnerStalled())
 		}));
 		const taskJson = yield* fs.readFileString(pathService.join(worktree.directory, ".lalph", "task.json"));
-		const chosenTask = yield* decodeEffect(ChosenTask)(taskJson);
+		const chosenTask = yield* decodeEffect(ChosenTask)(taskJson).pipe(mapError$2(() => new ChosenTaskNotFound()), tap(fnUntraced(function* (task$1) {
+			if ((yield* prd.findById(task$1.id))?.state === "in-progress") return;
+			return yield* new ChosenTaskNotFound();
+		})));
 		taskId = chosenTask.id;
+		yield* source.ensureInProgress(taskId).pipe(timeoutOrElse({
+			duration: "1 minute",
+			onTimeout: () => fail$4(new RunnerStalled())
+		}));
 		yield* completeWith(options.startedDeferred, void_$1);
 		if (chosenTask.githubPrNumber) {
 			yield* exec`gh pr checkout ${chosenTask.githubPrNumber}`;
@@ -142489,6 +142522,9 @@ const run = fnUntraced(function* (options) {
 var RunnerStalled = class extends TaggedError("RunnerStalled") {
 	message = "The runner has stalled due to inactivity.";
 };
+var ChosenTaskNotFound = class extends TaggedError("ChosenTaskNotFound") {
+	message = "The AI agent failed to choose a task.";
+};
 const ChosenTask = fromJsonString(Struct({
 	id: String$1,
 	githubPrNumber: NullOr(Finite)
@@ -142624,7 +142660,7 @@ const commandSource = make$27("source").pipe(withDescription("Select the issue s
 
 //#endregion
 //#region package.json
-var version = "0.1.77";
+var version = "0.1.78";
 
 //#endregion
 //#region src/cli.ts

package/package.json

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

package/src/Github.ts

@@ -8,6 +8,7 @@ import {
   Option,
   pipe,
   RcMap,
+  Schedule,
   Schema,
   ServiceMap,
   Stream,
@@ -369,6 +370,25 @@ export const GithubIssueSource = Layer.effect(
         },
         Effect.mapError((cause) => new IssueSourceError({ cause })),
       ),
+      ensureInProgress: Effect.fnUntraced(
+        function* (issueId: string) {
+          const issueNumber = Number(issueId.slice(1))
+          yield* pipe(
+            github.request((rest) =>
+              rest.issues.get({
+                owner: cli.owner,
+                repo: cli.repo,
+                issue_number: issueNumber,
+              }),
+            ),
+            Effect.repeat({
+              until: (r) => hasLabel(r.data.labels, "in-progress"),
+              schedule: Schedule.spaced("1 second"),
+            }),
+          )
+        },
+        Effect.mapError((cause) => new IssueSourceError({ cause })),
+      ),
     })
   }),
 ).pipe(Layer.provide([Github.layer, GithubCli.layer]))

package/src/IssueSource.ts

@@ -21,6 +21,10 @@ export class IssueSource extends ServiceMap.Service<
     readonly cancelIssue: (
       issueId: string,
     ) => Effect.Effect<void, IssueSourceError>
+
+    readonly ensureInProgress: (
+      issueId: string,
+    ) => Effect.Effect<void, IssueSourceError>
   }
 >()("lalph/IssueSource") {}
 
@@ -42,6 +46,25 @@ export const checkForWork = Effect.gen(function* () {
   }
 })
 
+export const resetInProgress = Effect.gen(function* () {
+  const source = yield* IssueSource
+  const issues = yield* source.issues
+  const inProgress = issues.filter(
+    (issue): issue is PrdIssue & { id: string } =>
+      issue.state === "in-progress" && issue.id !== null,
+  )
+  if (inProgress.length === 0) return
+  yield* Effect.forEach(
+    inProgress,
+    (issue) =>
+      source.updateIssue({
+        issueId: issue.id,
+        state: "todo",
+      }),
+    { concurrency: 5, discard: true },
+  )
+})
+
 export class NoMoreWork extends Schema.ErrorClass<NoMoreWork>(
   "lalph/Prd/NoMoreWork",
 )({

package/src/Linear.ts

@@ -230,8 +230,11 @@ export const LinearIssueSource = Layer.effect(
             const linearState = linear.states.find(
               (s) => s.id === issue.stateId,
             )!
-            const blockedBy = yield* Stream.runCollect(linear.blockedBy(issue))
             const state = linearStateToPrdState(linearState)
+            const blockedBy =
+              state === "todo"
+                ? yield* Stream.runCollect(linear.blockedBy(issue))
+                : []
             return new PrdIssue({
               id: issue.identifier,
               title: issue.title,
@@ -377,6 +380,8 @@ export const LinearIssueSource = Layer.effect(
         },
         Effect.mapError((cause) => new IssueSourceError({ cause })),
       ),
+      // linear api writes and reflected immediately in reads, so no-op
+      ensureInProgress: () => Effect.void,
     })
   }),
 ).pipe(Layer.provide(Linear.layer))

package/src/commands/root.ts

@@ -24,7 +24,7 @@ import { ChildProcess } from "effect/unstable/process"
 import { Worktree } from "../Worktree.ts"
 import { getCommandPrefix, getOrSelectCliAgent } from "./agent.ts"
 import { Flag, CliError, Command } from "effect/unstable/cli"
-import { checkForWork } from "../IssueSource.ts"
+import { checkForWork, IssueSource, resetInProgress } from "../IssueSource.ts"
 import { CurrentIssueSource } from "../IssueSources.ts"
 import { GithubCli } from "../Github/Cli.ts"
 
@@ -124,9 +124,14 @@ export const commandRoot = Command.make("lalph", {
       const semaphore = Effect.makeSemaphoreUnsafe(runConcurrency)
       const fibers = yield* FiberSet.make()
 
+      yield* resetInProgress.pipe(Effect.provide(source))
+
       yield* Effect.log(
         `Executing ${iterationsDisplay} iteration(s) with concurrency ${runConcurrency}`,
       )
+      if (Option.isSome(targetBranch)) {
+        yield* Effect.log(`Using target branch: ${targetBranch.value}`)
+      }
 
       let iteration = 0
       let quit = false
@@ -217,6 +222,7 @@ const run = Effect.fnUntraced(
     const gh = yield* GithubCli
     const cliAgent = yield* getOrSelectCliAgent
     const prd = yield* Prd
+    const source = yield* IssueSource
 
     const exec = (
       template: TemplateStringsArray,
@@ -314,8 +320,23 @@ const run = Effect.fnUntraced(
       const taskJson = yield* fs.readFileString(
         pathService.join(worktree.directory, ".lalph", "task.json"),
       )
-      const chosenTask = yield* Schema.decodeEffect(ChosenTask)(taskJson)
+      const chosenTask = yield* Schema.decodeEffect(ChosenTask)(taskJson).pipe(
+        Effect.mapError(() => new ChosenTaskNotFound()),
+        Effect.tap(
+          Effect.fnUntraced(function* (task) {
+            const prdTask = yield* prd.findById(task.id)
+            if (prdTask?.state === "in-progress") return
+            return yield* new ChosenTaskNotFound()
+          }),
+        ),
+      )
       taskId = chosenTask.id
+      yield* source.ensureInProgress(taskId).pipe(
+        Effect.timeoutOrElse({
+          duration: "1 minute",
+          onTimeout: () => Effect.fail(new RunnerStalled()),
+        }),
+      )
 
       yield* Deferred.completeWith(options.startedDeferred, Effect.void)
 
@@ -407,6 +428,10 @@ class RunnerStalled extends Data.TaggedError("RunnerStalled") {
   readonly message = "The runner has stalled due to inactivity."
 }
 
+class ChosenTaskNotFound extends Data.TaggedError("ChosenTaskNotFound") {
+  readonly message = "The AI agent failed to choose a task."
+}
+
 const ChosenTask = Schema.fromJsonString(
   Schema.Struct({
     id: Schema.String,