lalph 0.1.1 → 0.1.2

package/README.md

@@ -6,22 +6,14 @@ A small CLI that connects to Linear, pulls the next set of unstarted issues into
 
 - Install dependencies: `pnpm install`
 - Build the CLI: `pnpm build`
+- Add `.lalph/` to `.gitignore` to keep local state private
 
 ## CLI usage
 
 - 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 + format: `pnpm 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);
@@ -132224,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!";
@@ -132293,8 +132354,6 @@ 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
@@ -132349,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,
@@ -132356,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",
@@ -132392,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.1",
+  "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())
 
@@ -97,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]),
   )
 }
 

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,13 +7,6 @@ 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
 

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,
 )