lalph 0.1.0 → 0.1.2

package/README.md

@@ -5,24 +5,15 @@ A small CLI that connects to Linear, pulls the next set of unstarted issues into
 ## Setup
 
 - Install dependencies: `pnpm install`
-- Build the CLI: `pnpm exec tsc`
+- Build the CLI: `pnpm build`
+- Add `.lalph/` to `.gitignore` to keep local state private
 
 ## CLI usage
 
-- Run the main loop: `node dist/cli.js`
-- Select a Linear project: `node dist/cli.js select-project`
-- Select a label filter: `node dist/cli.js select-label`
-- Select a CLI agent: `node dist/cli.js select-agent`
+- Run the main loop: `npx -y lalph@latest`
+- Run multiple iterations with concurrency: `npx -y lalph@latest --iterations 4 --concurrency 2`
+- Select a Linear project: `npx -y lalph@latest select-project`
+- Select a label filter: `npx -y lalph@latest select-label`
+- Select a CLI agent: `npx -y lalph@latest select-agent`
 
 The first run opens a Linear OAuth flow and stores the token locally.
-
-## Generated files
-
-- `.lalph/prd.json`: synced task list pulled from Linear; update task states here.
-- `PROGRESS.md`: append-only log of work completed by the agent.
-- `.lalph/config`: local key-value store for Linear tokens and user selections.
-
-## Checks
-
-- Type check: `pnpm exec tsc --noEmit`
-- Format check: `pnpm exec prettier --check .`

package/dist/cli.mjs

@@ -8270,8 +8270,8 @@ const whileLoop$1 = /* @__PURE__ */ makePrimitive$1({
 /** @internal */
 const forEach$2 = /* @__PURE__ */ dual((args$1) => typeof args$1[1] === "function", (iterable, f, options) => withFiber$1((parent) => {
 	const concurrencyOption = options?.concurrency === "inherit" ? parent.getRef(CurrentConcurrency) : options?.concurrency ?? 1;
-	const concurrency = concurrencyOption === "unbounded" ? Number.POSITIVE_INFINITY : Math.max(1, concurrencyOption);
-	if (concurrency === 1) return forEachSequential(iterable, f, options);
+	const concurrency$1 = concurrencyOption === "unbounded" ? Number.POSITIVE_INFINITY : Math.max(1, concurrencyOption);
+	if (concurrency$1 === 1) return forEachSequential(iterable, f, options);
 	const items = fromIterable$2(iterable);
 	let length = items.length;
 	if (length === 0) return options?.discard ? void_$3 : succeed$4([]);
@@ -8288,7 +8288,7 @@ const forEach$2 = /* @__PURE__ */ dual((args$1) => typeof args$1[1] === "functio
 		let interrupted = false;
 		function pump() {
 			pumping = true;
-			while (inProgress < concurrency && index < length) {
+			while (inProgress < concurrency$1 && index < length) {
 				const currentIndex = index;
 				const item = items[currentIndex];
 				index++;
@@ -8312,7 +8312,7 @@ const forEach$2 = /* @__PURE__ */ dual((args$1) => typeof args$1[1] === "functio
 						doneCount++;
 						inProgress--;
 						if (doneCount === length) resume(failures.length > 0 ? exitFailCause(causeFromFailures(failures)) : succeed$4(out));
-						else if (!pumping && !failed && inProgress < concurrency) pump();
+						else if (!pumping && !failed && inProgress < concurrency$1) pump();
 					});
 				} catch (err) {
 					failed = true;
@@ -18354,6 +18354,35 @@ const logWithLevel = logWithLevel$1;
 */
 const log$1 = /* @__PURE__ */ logWithLevel$1();
 /**
+* Logs one or more messages at the WARNING level.
+*
+* @example
+* ```ts
+* import { Effect } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   yield* Effect.logWarning("API rate limit approaching")
+*   yield* Effect.logWarning("Retries remaining:", 2, "Operation:", "fetchData")
+*
+*   // Useful for non-critical issues
+*   const deprecated = true
+*   if (deprecated) {
+*     yield* Effect.logWarning("Using deprecated API endpoint")
+*   }
+* })
+*
+* Effect.runPromise(program)
+* // Output:
+* // timestamp=2023-... level=WARN message="API rate limit approaching"
+* // timestamp=2023-... level=WARN message="Retries remaining: 2 Operation: fetchData"
+* // timestamp=2023-... level=WARN message="Using deprecated API endpoint"
+* ```
+*
+* @since 2.0.0
+* @category logging
+*/
+const logWarning = /* @__PURE__ */ logWithLevel$1("Warn");
+/**
 * Logs one or more messages at the ERROR level.
 *
 * @example
@@ -53211,12 +53240,12 @@ var require_limiter = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
 		* @param {Number} [concurrency=Infinity] The maximum number of jobs allowed
 		*     to run concurrently
 		*/
-		constructor(concurrency) {
+		constructor(concurrency$1) {
 			this[kDone] = () => {
 				this.pending--;
 				this[kRun]();
 			};
-			this.concurrency = concurrency || Infinity;
+			this.concurrency = concurrency$1 || Infinity;
 			this.jobs = [];
 			this.pending = 0;
 		}
@@ -132176,9 +132205,42 @@ const teamSelect = fnUntraced(function* (project) {
 	yield* selectedTeamId.set(some(teamId));
 });
 
+//#endregion
+//#region src/Worktree.ts
+var Worktree = class extends Service()("lalph/Worktree", { make: gen(function* () {
+	const fs = yield* FileSystem;
+	const pathService = yield* Path$1;
+	const directory = yield* fs.makeTempDirectory();
+	yield* addFinalizer(fnUntraced(function* () {
+		yield* execIgnore(make$21`git worktree remove ${directory}`);
+	}));
+	yield* exec(make$21`git worktree add ${directory} -d HEAD`);
+	yield* fs.makeDirectory(pathService.join(directory, ".lalph"), { recursive: true });
+	yield* forEach$1([
+		make$21({
+			cwd: directory,
+			extendEnv: true,
+			shell: process.env.SHELL ?? true
+		})`direnv allow`,
+		make$21({
+			cwd: directory,
+			extendEnv: true,
+			shell: process.env.SHELL ?? true
+		})`devenv allow`,
+		make$21({ cwd: directory })`git submodule update --init --recursive`
+	], execIgnore, { concurrency: "unbounded" });
+	return { directory };
+}) }) {
+	static layer = effect(this, this.make);
+};
+const exec = (command) => command.asEffect().pipe(flatMap((proc) => proc.exitCode), scoped$1);
+const execIgnore = (command) => command.asEffect().pipe(flatMap((proc) => proc.exitCode), catchCause$1(logWarning), scoped$1);
+
 //#endregion
 //#region src/Prd.ts
 var Prd = class extends Service()("lalph/Prd", { make: gen(function* () {
+	const worktree = yield* Worktree;
+	const pathService = yield* Path$1;
 	const fs = yield* FileSystem;
 	const linear = yield* Linear;
 	const project = yield* CurrentProject;
@@ -132190,7 +132252,7 @@ var Prd = class extends Service()("lalph/Prd", { make: gen(function* () {
 	} })).pipe(runCollect).pipe(map$4(PrdList.fromLinearIssues));
 	if (initial.issues.size === 0) return yield* new NoMoreWork({});
 	const current = yield* make$22(initial);
-	const prdFile = `.lalph/prd.json`;
+	const prdFile = pathService.join(worktree.directory, `.lalph/prd.json`);
 	yield* fs.writeFileString(prdFile, initial.toJson());
 	const sync$2 = gen(function* () {
 		const json = yield* fs.readFileString(prdFile);
@@ -132212,7 +132274,8 @@ var Prd = class extends Service()("lalph/Prd", { make: gen(function* () {
 			}
 			const existing = currentValue.issues.get(issue.id);
 			if (!existing || !existing.isChangedComparedTo(issue)) continue;
-			yield* linear.use((c) => c.updateIssue(issue.id, {
+			const original = currentValue.orignals.get(issue.id);
+			yield* linear.use((c) => c.updateIssue(original.id, {
 				description: issue.description,
 				stateId: issue.stateId
 			}));
@@ -132223,13 +132286,12 @@ var Prd = class extends Service()("lalph/Prd", { make: gen(function* () {
 		capacity: 1,
 		strategy: "dropping"
 	}), runForEach(() => ignore(sync$2)), forkScoped);
-	return { current };
+	return {
+		current,
+		path: prdFile
+	};
 }) }) {
-	static layer = effect(this, this.make).pipe(provide$2([
-		Linear.layer,
-		Settings.layer,
-		CurrentProject.layer
-	]));
+	static layer = effect(this, this.make).pipe(provide$2([CurrentProject.layer, Worktree.layer]));
 };
 var NoMoreWork = class extends ErrorClass("lalph/Prd/NoMoreWork")({ _tag: tag("NoMoreWork") }) {
 	message = "No more work to be done!";
@@ -132251,7 +132313,7 @@ var PrdIssue = class PrdIssue extends Class("PrdIssue")({
 	};
 	static fromLinearIssue(issue) {
 		return new PrdIssue({
-			id: issue.id,
+			id: issue.identifier,
 			title: issue.title,
 			description: issue.description ?? "",
 			priority: issue.priority,
@@ -132266,12 +132328,17 @@ var PrdIssue = class PrdIssue extends Class("PrdIssue")({
 var PrdList = class PrdList extends Class$1 {
 	static fromLinearIssues(issues) {
 		const map$12 = /* @__PURE__ */ new Map();
+		const originalMap = /* @__PURE__ */ new Map();
 		for (const issue of issues) {
 			const prdIssue = PrdIssue.fromLinearIssue(issue);
 			if (!prdIssue.id) continue;
 			map$12.set(prdIssue.id, prdIssue);
+			originalMap.set(prdIssue.id, issue);
 		}
-		return new PrdList({ issues: map$12 });
+		return new PrdList({
+			issues: map$12,
+			orignals: originalMap
+		});
 	}
 	static fromJson(json) {
 		return decodeSync(PrdIssue.ArrayFromJson)(JSON.parse(json));
@@ -132287,20 +132354,25 @@ var PrdList = class PrdList extends Class$1 {
 //#region src/PromptGen.ts
 var PromptGen = class extends Service()("lalph/PromptGen", { make: gen(function* () {
 	const linear = yield* Linear;
-	const fs = yield* FileSystem;
-	yield* scoped$1(fs.open("PROGRESS.md", { flag: "a+" }));
 	return { prompt: `# Instructions
 
 1. Decide which single task to work on next from the prd.json file. This should
    be the task YOU decide as the most important to work on next, not just the
    first task in the list.
-   - **Important**: Before starting the chosen task, mark it as "in progress" by
-     updating its \`stateId\` in the prd.json file.
-     This prevents other people or agents from working on the same task simultaneously.
-3. Run any checks / feedback loops, such as type checks, unit tests, or linting.
-4. APPEND your progress to the PROGRESS.md file.
-5. Make a git commit when you have made significant progress or completed the task.
-6. Update the prd.json file to reflect any changes in task states.
+2. Before starting the chosen task, mark it as "in progress" by updating its
+   \`stateId\` in the prd.json file.
+   This prevents other people or agents from working on the same task simultaneously.
+3. Check if there is an existing Github PR for the task, otherwise create a new
+   branch for the task.
+   - If there is an existing PR, checkout the branch for that PR.
+   - If there is an existing PR, check if there are any new comments or requested
+     changes, and address them as part of the task.
+4. Run any checks / feedback loops, such as type checks, unit tests, or linting.
+5. APPEND your progress to the PROGRESS.md file.
+6. Create or update the pull request with your changes once the task is complete. The title of
+   the PR should include the task id. The PR description should include a
+   summary of the changes made.
+7. Update the prd.json file to reflect any changes in task states.
    - Add follow up tasks only if needed.
    - Append to the \`description\` field with any notes.
    - When a task is complete, set its \`stateId\` to the id that indicates
@@ -132336,6 +132408,7 @@ ${JSON.stringify(PrdIssue.jsonSchema, null, 2)}
 //#endregion
 //#region src/Runner.ts
 const run = gen(function* () {
+	const worktree = yield* Worktree;
 	const promptGen = yield* PromptGen;
 	const cliCommand = (yield* getOrSelectCliAgent).command({
 		prompt: promptGen.prompt,
@@ -132343,13 +132416,18 @@ const run = gen(function* () {
 		progressFilePath: "PROGRESS.md"
 	});
 	const exitCode = yield* (yield* make$21(cliCommand[0], cliCommand.slice(1), {
+		cwd: worktree.directory,
 		extendEnv: true,
 		stdout: "inherit",
 		stderr: "inherit",
 		stdin: "inherit"
 	})).exitCode;
 	yield* log$1(`Agent exited with code: ${exitCode}`);
-}).pipe(scoped$1, provide([PromptGen.layer, Prd.layer]));
+}).pipe(scoped$1, provide([
+	PromptGen.layer,
+	Prd.layer,
+	Worktree.layer
+]));
 const selectCliAgent = gen(function* () {
 	const agent = yield* select({
 		message: "Select the CLI agent to use",
@@ -132379,18 +132457,51 @@ const selectLabel = make$26("select-label").pipe(withDescription("Select the lab
 		onNone: () => "No Label",
 		onSome: (l) => l.name
 	})}`);
-}, provide(Linear.layer))));
+})));
 const selectAgent = make$26("select-agent").pipe(withDescription("Select the CLI agent to use"), withHandler(() => selectCliAgent));
-const iterations = integer("iterations").pipe(withAlias("i"), withDefault(1));
-const root = make$26("lalph", { iterations }).pipe(withHandler(fnUntraced(function* ({ iterations: iterations$1 }) {
-	yield* log$1(`Executing ${iterations$1} iteration(s)`);
-	for (let i = 0; i < iterations$1; i++) yield* run;
+const iterations = integer("iterations").pipe(withDescription$1("Number of iterations to run, defaults to unlimited"), withAlias("i"), withDefault(Number.POSITIVE_INFINITY));
+const concurrency = integer("concurrency").pipe(withDescription$1("Number of concurrent agents, defaults to 1"), withAlias("c"), withDefault(1));
+const root = make$26("lalph", {
+	iterations,
+	concurrency
+}).pipe(withHandler(fnUntraced(function* ({ iterations: iterations$1, concurrency: concurrency$1 }) {
+	const isFinite$3 = Number.isFinite(iterations$1);
+	const iterationsDisplay = isFinite$3 ? iterations$1 : "unlimited";
+	const runConcurrency = Math.max(1, concurrency$1);
+	const semaphore = makeSemaphoreUnsafe(runConcurrency);
+	yield* log$1(`Executing ${iterationsDisplay} iteration(s) with concurrency ${runConcurrency}`);
+	let iteration = 0;
+	let lastStartedAt = makeUnsafe$3(0);
+	let inProgress = 0;
+	while (true) {
+		yield* semaphore.take(1);
+		if (isFinite$3 && iteration >= iterations$1) break;
+		const currentIteration = iteration;
+		if (inProgress > 0) {
+			const nextEarliestStart = lastStartedAt.pipe(add$1({ seconds: 30 }));
+			const diff = distance(yield* now, nextEarliestStart);
+			if (diff > 0) yield* sleep(diff);
+		}
+		lastStartedAt = yield* now;
+		inProgress++;
+		yield* run.pipe(catchTag("NoMoreWork", (e) => {
+			if (isFinite$3) {
+				iterations$1 = currentIteration;
+				return fail$3(e);
+			}
+			return log$1("No more work to process, waiting 30 seconds...").pipe(andThen(sleep("30 seconds")));
+		}), catchCause$1(logWarning), annotateLogs({ iteration: currentIteration }), ensuring(suspend$2(() => {
+			inProgress--;
+			return semaphore.release(1);
+		})), forkChild);
+		iteration++;
+	}
 })), withSubcommands([
 	selectProject,
 	selectLabel,
 	selectAgent
 ]));
-run$1(root, { version: "0.1.0" }).pipe(provide(Settings.layer.pipe(provideMerge(layer$1))), runMain);
+run$1(root, { version: "0.1.0" }).pipe(provide(mergeAll(Settings.layer, Linear.layer).pipe(provideMerge(layer$1))), runMain);
 
 //#endregion
 export {  };

package/package.json

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

package/src/Prd.ts

@@ -4,17 +4,21 @@ import {
   FileSystem,
   Layer,
   Option,
+  Path,
   Schema,
   ServiceMap,
   Stream,
   SubscriptionRef,
 } from "effect"
 import { CurrentProject, Linear } from "./Linear.ts"
-import { selectedLabelId, selectedTeamId, Settings } from "./Settings.ts"
+import { selectedLabelId, selectedTeamId } from "./Settings.ts"
 import type { Issue } from "@linear/sdk"
+import { Worktree } from "./Worktree.ts"
 
 export class Prd extends ServiceMap.Service<Prd>()("lalph/Prd", {
   make: Effect.gen(function* () {
+    const worktree = yield* Worktree
+    const pathService = yield* Path.Path
     const fs = yield* FileSystem.FileSystem
     const linear = yield* Linear
     const project = yield* CurrentProject
@@ -46,7 +50,7 @@ export class Prd extends ServiceMap.Service<Prd>()("lalph/Prd", {
 
     const current = yield* SubscriptionRef.make(initial)
 
-    const prdFile = `.lalph/prd.json`
+    const prdFile = pathService.join(worktree.directory, `.lalph/prd.json`)
 
     yield* fs.writeFileString(prdFile, initial.toJson())
 
@@ -74,10 +78,11 @@ export class Prd extends ServiceMap.Service<Prd>()("lalph/Prd", {
         }
         const existing = currentValue.issues.get(issue.id)
         if (!existing || !existing.isChangedComparedTo(issue)) continue
+        const original = currentValue.orignals.get(issue.id)!
 
         // update existing issue
         yield* linear.use((c) =>
-          c.updateIssue(issue.id!, {
+          c.updateIssue(original.id, {
             description: issue.description,
             stateId: issue.stateId,
           }),
@@ -96,11 +101,11 @@ export class Prd extends ServiceMap.Service<Prd>()("lalph/Prd", {
       Effect.forkScoped,
     )
 
-    return { current } as const
+    return { current, path: prdFile } as const
   }),
 }) {
   static layer = Layer.effect(this, this.make).pipe(
-    Layer.provide([Linear.layer, Settings.layer, CurrentProject.layer]),
+    Layer.provide([CurrentProject.layer, Worktree.layer]),
   )
 }
 
@@ -146,7 +151,7 @@ export class PrdIssue extends Schema.Class<PrdIssue>("PrdIssue")({
 
   static fromLinearIssue(issue: Issue): PrdIssue {
     return new PrdIssue({
-      id: issue.id,
+      id: issue.identifier,
       title: issue.title,
       description: issue.description ?? "",
       priority: issue.priority,
@@ -164,15 +169,18 @@ export class PrdIssue extends Schema.Class<PrdIssue>("PrdIssue")({
 
 export class PrdList extends Data.Class<{
   readonly issues: ReadonlyMap<string, PrdIssue>
+  readonly orignals: ReadonlyMap<string, Issue>
 }> {
   static fromLinearIssues(issues: Issue[]): PrdList {
     const map = new Map<string, PrdIssue>()
+    const originalMap = new Map<string, Issue>()
     for (const issue of issues) {
       const prdIssue = PrdIssue.fromLinearIssue(issue)
       if (!prdIssue.id) continue
       map.set(prdIssue.id, prdIssue)
+      originalMap.set(prdIssue.id, issue)
     }
-    return new PrdList({ issues: map })
+    return new PrdList({ issues: map, orignals: originalMap })
   }
 
   static fromJson(json: string): ReadonlyArray<PrdIssue> {

package/src/PromptGen.ts

@@ -1,4 +1,4 @@
-import { Effect, FileSystem, Layer, ServiceMap } from "effect"
+import { Effect, Layer, ServiceMap } from "effect"
 import { Linear } from "./Linear.ts"
 import { PrdIssue } from "./Prd.ts"
 
@@ -7,26 +7,26 @@ export class PromptGen extends ServiceMap.Service<PromptGen>()(
   {
     make: Effect.gen(function* () {
       const linear = yield* Linear
-      const fs = yield* FileSystem.FileSystem
-
-      yield* Effect.scoped(
-        fs.open("PROGRESS.md", {
-          flag: "a+",
-        }),
-      )
 
       const prompt = `# Instructions
 
 1. Decide which single task to work on next from the prd.json file. This should
    be the task YOU decide as the most important to work on next, not just the
    first task in the list.
-   - **Important**: Before starting the chosen task, mark it as "in progress" by
-     updating its \`stateId\` in the prd.json file.
-     This prevents other people or agents from working on the same task simultaneously.
-3. Run any checks / feedback loops, such as type checks, unit tests, or linting.
-4. APPEND your progress to the PROGRESS.md file.
-5. Make a git commit when you have made significant progress or completed the task.
-6. Update the prd.json file to reflect any changes in task states.
+2. Before starting the chosen task, mark it as "in progress" by updating its
+   \`stateId\` in the prd.json file.
+   This prevents other people or agents from working on the same task simultaneously.
+3. Check if there is an existing Github PR for the task, otherwise create a new
+   branch for the task.
+   - If there is an existing PR, checkout the branch for that PR.
+   - If there is an existing PR, check if there are any new comments or requested
+     changes, and address them as part of the task.
+4. Run any checks / feedback loops, such as type checks, unit tests, or linting.
+5. APPEND your progress to the PROGRESS.md file.
+6. Create or update the pull request with your changes once the task is complete. The title of
+   the PR should include the task id. The PR description should include a
+   summary of the changes made.
+7. Update the prd.json file to reflect any changes in task states.
    - Add follow up tasks only if needed.
    - Append to the \`description\` field with any notes.
    - When a task is complete, set its \`stateId\` to the id that indicates

package/src/Runner.ts

@@ -5,16 +5,20 @@ import { ChildProcess } from "effect/unstable/process"
 import { Prompt } from "effect/unstable/cli"
 import { allCliAgents } from "./domain/CliAgent.ts"
 import { selectedCliAgentId } from "./Settings.ts"
+import { Worktree } from "./Worktree.ts"
 
 export const run = Effect.gen(function* () {
+  const worktree = yield* Worktree
   const promptGen = yield* PromptGen
   const cliAgent = yield* getOrSelectCliAgent
+
   const cliCommand = cliAgent.command({
     prompt: promptGen.prompt,
     prdFilePath: ".lalph/prd.json",
     progressFilePath: "PROGRESS.md",
   })
   const command = ChildProcess.make(cliCommand[0]!, cliCommand.slice(1), {
+    cwd: worktree.directory,
     extendEnv: true,
     stdout: "inherit",
     stderr: "inherit",
@@ -25,7 +29,10 @@ export const run = Effect.gen(function* () {
   const exitCode = yield* agent.exitCode
 
   yield* Effect.log(`Agent exited with code: ${exitCode}`)
-}).pipe(Effect.scoped, Effect.provide([PromptGen.layer, Prd.layer]))
+}).pipe(
+  Effect.scoped,
+  Effect.provide([PromptGen.layer, Prd.layer, Worktree.layer]),
+)
 
 export const selectCliAgent = Effect.gen(function* () {
   const agent = yield* Prompt.select({

package/src/Worktree.ts

@@ -0,0 +1,59 @@
+import { Effect, FileSystem, Layer, Path, ServiceMap } from "effect"
+import { ChildProcess } from "effect/unstable/process"
+
+export class Worktree extends ServiceMap.Service<Worktree>()("lalph/Worktree", {
+  make: Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem
+    const pathService = yield* Path.Path
+    const directory = yield* fs.makeTempDirectory()
+
+    yield* Effect.addFinalizer(
+      Effect.fnUntraced(function* () {
+        yield* execIgnore(ChildProcess.make`git worktree remove ${directory}`)
+      }),
+    )
+
+    yield* exec(ChildProcess.make`git worktree add ${directory} -d HEAD`)
+
+    yield* fs.makeDirectory(pathService.join(directory, ".lalph"), {
+      recursive: true,
+    })
+
+    yield* Effect.forEach(
+      [
+        ChildProcess.make({
+          cwd: directory,
+          extendEnv: true,
+          shell: process.env.SHELL ?? true,
+        })`direnv allow`,
+        ChildProcess.make({
+          cwd: directory,
+          extendEnv: true,
+          shell: process.env.SHELL ?? true,
+        })`devenv allow`,
+        ChildProcess.make({
+          cwd: directory,
+        })`git submodule update --init --recursive`,
+      ],
+      execIgnore,
+      { concurrency: "unbounded" },
+    )
+
+    return { directory } as const
+  }),
+}) {
+  static layer = Layer.effect(this, this.make)
+}
+
+const exec = (command: ChildProcess.Command) =>
+  command.asEffect().pipe(
+    Effect.flatMap((proc) => proc.exitCode),
+    Effect.scoped,
+  )
+
+const execIgnore = (command: ChildProcess.Command) =>
+  command.asEffect().pipe(
+    Effect.flatMap((proc) => proc.exitCode),
+    Effect.catchCause(Effect.logWarning),
+    Effect.scoped,
+  )

package/src/cli.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import { Command, Flag } from "effect/unstable/cli"
-import { Effect, Layer, Option } from "effect"
+import { DateTime, Effect, Layer, Option } from "effect"
 import { NodeRuntime, NodeServices } from "@effect/platform-node"
 import { CurrentProject, labelSelect, Linear } from "./Linear.ts"
 import { layerKvs } from "./Kvs.ts"
@@ -34,7 +34,7 @@ const selectLabel = Command.make("select-label").pipe(
           onSome: (l) => l.name,
         })}`,
       )
-    }, Effect.provide(Linear.layer)),
+    }),
   ),
 )
 
@@ -44,17 +44,80 @@ const selectAgent = Command.make("select-agent").pipe(
 )
 
 const iterations = Flag.integer("iterations").pipe(
+  Flag.withDescription("Number of iterations to run, defaults to unlimited"),
   Flag.withAlias("i"),
+  Flag.withDefault(Number.POSITIVE_INFINITY),
+)
+
+const concurrency = Flag.integer("concurrency").pipe(
+  Flag.withDescription("Number of concurrent agents, defaults to 1"),
+  Flag.withAlias("c"),
   Flag.withDefault(1),
 )
 
-const root = Command.make("lalph", { iterations }).pipe(
+const root = Command.make("lalph", { iterations, concurrency }).pipe(
   Command.withHandler(
-    Effect.fnUntraced(function* ({ iterations }) {
-      yield* Effect.log(`Executing ${iterations} iteration(s)`)
+    Effect.fnUntraced(function* ({ iterations, concurrency }) {
+      const isFinite = Number.isFinite(iterations)
+      const iterationsDisplay = isFinite ? iterations : "unlimited"
+      const runConcurrency = Math.max(1, concurrency)
+      const semaphore = Effect.makeSemaphoreUnsafe(runConcurrency)
+
+      yield* Effect.log(
+        `Executing ${iterationsDisplay} iteration(s) with concurrency ${runConcurrency}`,
+      )
+
+      let iteration = 0
+      let lastStartedAt = DateTime.makeUnsafe(0)
+      let inProgress = 0
 
-      for (let i = 0; i < iterations; i++) {
-        yield* run
+      while (true) {
+        yield* semaphore.take(1)
+        if (isFinite && iteration >= iterations) {
+          break
+        }
+
+        const currentIteration = iteration
+
+        if (inProgress > 0) {
+          // add delay to try keep task list in sync
+          const nextEarliestStart = lastStartedAt.pipe(
+            DateTime.add({ seconds: 30 }),
+          )
+          const diff = DateTime.distance(yield* DateTime.now, nextEarliestStart)
+          if (diff > 0) {
+            yield* Effect.sleep(diff)
+          }
+        }
+
+        lastStartedAt = yield* DateTime.now
+        inProgress++
+
+        yield* run.pipe(
+          Effect.catchTag("NoMoreWork", (e) => {
+            if (isFinite) {
+              // If we have a finite number of iterations, we exit when no more
+              // work is found
+              iterations = currentIteration
+              return Effect.fail(e)
+            }
+            return Effect.log(
+              "No more work to process, waiting 30 seconds...",
+            ).pipe(Effect.andThen(Effect.sleep("30 seconds")))
+          }),
+          Effect.catchCause(Effect.logWarning),
+          Effect.annotateLogs({
+            iteration: currentIteration,
+          }),
+          Effect.ensuring(
+            Effect.suspend(() => {
+              inProgress--
+              return semaphore.release(1)
+            }),
+          ),
+          Effect.forkChild,
+        )
+        iteration++
       }
     }),
   ),
@@ -64,6 +127,10 @@ const root = Command.make("lalph", { iterations }).pipe(
 Command.run(root, {
   version: "0.1.0",
 }).pipe(
-  Effect.provide(Settings.layer.pipe(Layer.provideMerge(NodeServices.layer))),
+  Effect.provide(
+    Layer.mergeAll(Settings.layer, Linear.layer).pipe(
+      Layer.provideMerge(NodeServices.layer),
+    ),
+  ),
   NodeRuntime.runMain,
 )