lalph 0.3.7 → 0.3.8

package/dist/cli.mjs

@@ -6268,7 +6268,7 @@ const append$1 = /* @__PURE__ */ dual(2, (self, last) => [...self, last]);
 * @category concatenating
 * @since 2.0.0
 */
-const appendAll$2 = /* @__PURE__ */ dual(2, (self, that) => fromIterable$4(self).concat(fromIterable$4(that)));
+const appendAll$1 = /* @__PURE__ */ dual(2, (self, that) => fromIterable$4(self).concat(fromIterable$4(that)));
 /**
 * Determine if `unknown` is an Array.
 *
@@ -6574,7 +6574,7 @@ const unionWith = /* @__PURE__ */ dual(3, (self, that, isEquivalent) => {
 	const a = fromIterable$4(self);
 	const b = fromIterable$4(that);
 	if (isReadonlyArrayNonEmpty(a)) {
-		if (isReadonlyArrayNonEmpty(b)) return dedupeWith(isEquivalent)(appendAll$2(a, b));
+		if (isReadonlyArrayNonEmpty(b)) return dedupeWith(isEquivalent)(appendAll$1(a, b));
 		return a;
 	}
 	return b;
@@ -25930,7 +25930,7 @@ const drop = /* @__PURE__ */ dual(2, (self, n) => {
 * @category concatenating
 * @since 2.0.0
 */
-const appendAll$1 = /* @__PURE__ */ dual(2, (self, that) => {
+const appendAll = /* @__PURE__ */ dual(2, (self, that) => {
 	if (self.backing._tag === "IEmpty") return that;
 	if (that.backing._tag === "IEmpty") return self;
 	const diff = that.depth - self.depth;
@@ -25940,14 +25940,14 @@ const appendAll$1 = /* @__PURE__ */ dual(2, (self, that) => {
 		right: that
 	});
 	else if (diff < -1) if (self.left.depth >= self.right.depth) {
-		const nr = appendAll$1(self.right, that);
+		const nr = appendAll(self.right, that);
 		return makeChunk({
 			_tag: "IConcat",
 			left: self.left,
 			right: nr
 		});
 	} else {
-		const nrr = appendAll$1(self.right.right, that);
+		const nrr = appendAll(self.right.right, that);
 		if (nrr.depth === self.depth - 3) {
 			const nr = makeChunk({
 				_tag: "IConcat",
@@ -25971,11 +25971,11 @@ const appendAll$1 = /* @__PURE__ */ dual(2, (self, that) => {
 	}
 	else if (that.right.depth >= that.left.depth) return makeChunk({
 		_tag: "IConcat",
-		left: appendAll$1(self, that.left),
+		left: appendAll(self, that.left),
 		right: that.right
 	});
 	else {
-		const nll = appendAll$1(self, that.left.left);
+		const nll = appendAll(self, that.left.left);
 		if (nll.depth === that.depth - 3) return makeChunk({
 			_tag: "IConcat",
 			left: makeChunk({
@@ -26472,42 +26472,6 @@ const runIn = fiberRunIn;
 //#endregion
 //#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@3519468_8750329d33fefc387eb55044ef2141e0/node_modules/effect/dist/MutableList.js
 /**
-* @fileoverview
-* MutableList is an efficient, mutable linked list implementation optimized for high-throughput
-* scenarios like logging, queuing, and streaming. It uses a bucket-based architecture where
-* elements are stored in arrays (buckets) linked together, providing optimal performance for
-* both append and prepend operations.
-*
-* The implementation uses a sophisticated bucket system:
-* - Each bucket contains an array of elements with an offset pointer
-* - Buckets can be marked as mutable or immutable for optimization
-* - Elements are taken from the head and added to the tail
-* - Memory is efficiently managed through bucket reuse and cleanup
-*
-* Key Features:
-* - Highly optimized for high-frequency append/prepend operations
-* - Memory efficient with automatic cleanup of consumed elements
-* - Support for bulk operations (appendAll, prependAll, takeN)
-* - Filtering and removal operations
-* - Zero-copy optimizations for certain scenarios
-*
-* Performance Characteristics:
-* - Append/Prepend: O(1) amortized
-* - Take/TakeN: O(1) per element taken
-* - Length: O(1)
-* - Clear: O(1)
-* - Filter: O(n)
-*
-* Ideal Use Cases:
-* - High-throughput logging systems
-* - Producer-consumer queues
-* - Streaming data buffers
-* - Real-time data processing pipelines
-*
-* @since 4.0.0
-* @category data-structures
-*/
-/**
 * A unique symbol used to represent an empty result when taking elements from a MutableList.
 * This symbol is returned by `take` when the list is empty, allowing for safe type checking.
 *
@@ -26621,92 +26585,6 @@ const append = (self, message) => {
 	self.length++;
 };
 /**
-* Appends all elements from an iterable to the end of the MutableList.
-* Returns the number of elements added.
-*
-* @example
-* ```ts
-* import * as MutableList from "effect/MutableList"
-*
-* const list = MutableList.make<number>()
-* MutableList.append(list, 1)
-* MutableList.append(list, 2)
-*
-* // Append multiple elements
-* const added = MutableList.appendAll(list, [3, 4, 5])
-* console.log(added) // 3
-* console.log(list.length) // 5
-*
-* // Elements maintain order: [1, 2, 3, 4, 5]
-* console.log(MutableList.takeAll(list)) // [1, 2, 3, 4, 5]
-*
-* // Works with any iterable
-* const newList = MutableList.make<string>()
-* MutableList.appendAll(newList, new Set(["a", "b", "c"]))
-* console.log(MutableList.takeAll(newList)) // ["a", "b", "c"]
-*
-* // Useful for bulk loading
-* const bulkList = MutableList.make<number>()
-* const count = MutableList.appendAll(
-*   bulkList,
-*   Array.from({ length: 1000 }, (_, i) => i)
-* )
-* console.log(count) // 1000
-* ```
-*
-* @since 4.0.0
-* @category mutations
-*/
-const appendAll = (self, messages) => appendAllUnsafe(self, fromIterable$4(messages), !Array.isArray(messages));
-/**
-* Appends all elements from a ReadonlyArray to the end of the MutableList.
-* This is an optimized version that can reuse the array when mutable=true.
-* Returns the number of elements added.
-*
-* ⚠️ **Warning**: When mutable=true, the input array may be modified internally.
-* Only use mutable=true when you control the array lifecycle.
-*
-* @example
-* ```ts
-* import * as MutableList from "effect/MutableList"
-*
-* const list = MutableList.make<number>()
-* MutableList.append(list, 1)
-*
-* // Safe usage (default mutable=false)
-* const items = [2, 3, 4]
-* const added = MutableList.appendAllUnsafe(list, items)
-* console.log(added) // 3
-* console.log(items) // [2, 3, 4] - unchanged
-*
-* // Unsafe but efficient usage (mutable=true)
-* const mutableItems = [5, 6, 7]
-* MutableList.appendAllUnsafe(list, mutableItems, true)
-* // mutableItems may be modified internally for efficiency
-*
-* console.log(MutableList.takeAll(list)) // [1, 2, 3, 4, 5, 6, 7]
-*
-* // High-performance bulk operations
-* const bigArray = new Array(10000).fill(0).map((_, i) => i)
-* MutableList.appendAllUnsafe(list, bigArray, true) // Very efficient
-* ```
-*
-* @since 4.0.0
-* @category mutations
-*/
-const appendAllUnsafe = (self, messages, mutable = false) => {
-	const chunk = {
-		array: messages,
-		mutable,
-		offset: 0,
-		next: void 0
-	};
-	if (self.head) self.tail = self.tail.next = chunk;
-	else self.head = self.tail = chunk;
-	self.length += messages.length;
-	return messages.length;
-};
-/**
 * Removes all elements from the MutableList, resetting it to an empty state.
 * This operation is highly optimized and releases all internal memory.
 *
@@ -27333,9 +27211,6 @@ var PubSubImpl = class {
 
 //#endregion
 //#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@3519468_8750329d33fefc387eb55044ef2141e0/node_modules/effect/dist/Queue.js
-/**
-* @since 3.8.0
-*/
 const TypeId$47 = "~effect/Queue";
 const EnqueueTypeId = "~effect/Queue/Enqueue";
 const DequeueTypeId = "~effect/Queue/Dequeue";
@@ -27532,84 +27407,6 @@ const offerUnsafe = (self, message) => {
 	return true;
 };
 /**
-* Add multiple messages to the queue. Returns the remaining messages that
-* were not added.
-*
-* For bounded queues, this operation may suspend if the queue doesn't have
-* enough capacity. The operation returns an array of messages that couldn't
-* be added (empty array means all messages were successfully added).
-*
-* @example
-* ```ts
-* import { Cause, Effect, Queue } from "effect"
-*
-* const program = Effect.gen(function*() {
-*   const queue = yield* Queue.bounded<number>(3)
-*
-*   // Try to add more messages than capacity
-*   const remaining1 = yield* Queue.offerAll(queue, [1, 2, 3, 4, 5])
-*   console.log(remaining1) // [4, 5] - couldn't fit the last 2
-* })
-* ```
-*
-* @category Offering
-* @since 4.0.0
-*/
-const offerAll = (self, messages) => suspend$4(() => {
-	if (self.state._tag !== "Open") return succeed$5(fromIterable$4(messages));
-	const remaining = offerAllUnsafe(self, messages);
-	if (remaining.length === 0) return exitSucceed([]);
-	else if (self.strategy === "dropping") return succeed$5(remaining);
-	return offerRemainingArray(self, remaining);
-});
-/**
-* Add multiple messages to the queue synchronously. Returns the remaining messages that
-* were not added.
-*
-* This is an unsafe operation that directly modifies the queue without Effect wrapping.
-*
-* @example
-* ```ts
-* import { Cause, Effect, Queue } from "effect"
-*
-* // Create a bounded queue and use unsafe API
-* const program = Effect.gen(function*() {
-*   const queue = yield* Queue.bounded<number>(3)
-*
-*   // Try to add 5 messages to capacity-3 queue using unsafe API
-*   const remaining = Queue.offerAllUnsafe(queue, [1, 2, 3, 4, 5])
-*   console.log(remaining) // [4, 5] - couldn't fit the last 2
-*
-*   // Check what's in the queue
-*   const size = Queue.sizeUnsafe(queue)
-*   console.log(size) // 3
-* })
-* ```
-*
-* @category Offering
-* @since 4.0.0
-*/
-const offerAllUnsafe = (self, messages) => {
-	if (self.state._tag !== "Open") return fromIterable$4(messages);
-	else if (self.capacity === Number.POSITIVE_INFINITY || self.strategy === "sliding") {
-		appendAll(self.messages, messages);
-		if (self.strategy === "sliding") takeN(self.messages, self.messages.length - self.capacity);
-		scheduleReleaseTaker(self);
-		return [];
-	}
-	const free = self.capacity <= 0 ? self.state.takers.size : self.capacity - self.messages.length;
-	if (free === 0) return fromIterable$4(messages);
-	const remaining = [];
-	let i = 0;
-	for (const message of messages) {
-		if (i < free) append(self.messages, message);
-		else remaining.push(message);
-		i++;
-	}
-	scheduleReleaseTaker(self);
-	return remaining;
-};
-/**
 * Fail the queue with a cause. If the queue is already done, `false` is
 * returned.
 *
@@ -27996,21 +27793,6 @@ const offerRemainingSingle = (self, message) => {
 		});
 	});
 };
-const offerRemainingArray = (self, remaining) => {
-	return callback$2((resume) => {
-		if (self.state._tag !== "Open") return resume(exitSucceed(remaining));
-		const entry = {
-			_tag: "Array",
-			remaining,
-			offset: 0,
-			resume
-		};
-		self.state.offers.add(entry);
-		return sync$1(() => {
-			if (self.state._tag === "Open") self.state.offers.delete(entry);
-		});
-	});
-};
 const releaseCapacity = (self) => {
 	if (self.state._tag === "Done") return isDoneCause(self.state.exit.cause);
 	else if (self.state.offers.size === 0) {
@@ -29204,23 +28986,6 @@ const unwrap$2 = (channel) => fromTransform$1((upstream, scope) => {
 	}));
 });
 /**
-* Allows a faster producer to progress independently of a slower consumer by
-* buffering up to `capacity` elements in a queue.
-*
-* @since 2.0.0
-* @category Buffering
-*/
-const bufferArray = /* @__PURE__ */ dual(2, (self, options) => fromTransform$1(fnUntraced(function* (upstream, scope) {
-	const pull = yield* toTransform(self)(upstream, scope);
-	const queue = yield* make$46({
-		capacity: options.capacity === "unbounded" ? void 0 : options.capacity,
-		strategy: options.capacity === "unbounded" ? void 0 : options.strategy
-	});
-	yield* addFinalizer$1(scope, shutdown(queue));
-	yield* pull.pipe(flatMap$2((value) => offerAll(queue, value)), forever({ autoYield: false }), onError((cause) => failCause$1(queue, cause)), forkIn(scope));
-	return takeAll(queue);
-})));
-/**
 * Returns a new channel with an attached finalizer. The finalizer is
 * guaranteed to be executed so long as the channel begins execution (and
 * regardless of whether or not it completes).
@@ -30952,33 +30717,6 @@ const filter$2 = /* @__PURE__ */ dual(2, (self, predicate) => fromChannel(filter
 */
 const filterMapEffect = /* @__PURE__ */ dual(2, (self, filter) => fromChannel(filterMapArrayEffect(toChannel(self), filter)));
 /**
-* Buffers up to `capacity` elements so a faster producer can progress
-* independently of a slower consumer.
-*
-* Note: This combinator destroys chunking. Use `Stream.rechunk` afterwards if
-* you need fixed chunk sizes.
-*
-* @example
-* ```ts
-* import { Console, Effect, Stream } from "effect"
-*
-* const program = Effect.gen(function*() {
-*   const values = yield* Stream.make(1, 2, 3).pipe(
-*     Stream.buffer({ capacity: 1 }),
-*     Stream.runCollect
-*   )
-*   yield* Console.log(values)
-* })
-*
-* Effect.runPromise(program)
-* // Output: [ 1, 2, 3 ]
-* ```
-*
-* @since 2.0.0
-* @category Rate Limiting
-*/
-const buffer = /* @__PURE__ */ dual(2, (self, options) => fromChannel(bufferArray(self.channel, options)));
-/**
 * Transforms the errors emitted by this stream using `f`.
 *
 * @example
@@ -68652,7 +68390,7 @@ const makeStreamPullEffect = (get, pullSignal, create, options) => flatMap$2(toP
 			let items;
 			if (options?.disableAccumulation) items = chunk;
 			else {
-				items = appendAll$2(acc, chunk);
+				items = appendAll$1(acc, chunk);
 				acc = items;
 			}
 			return succeed$1({
@@ -151219,18 +150957,15 @@ To remove a task, simply delete the item from the prd.yml file.
 \`\`\`json
 ${JSON.stringify(PrdIssue.jsonSchema, null, 2)}
 \`\`\``;
-	const promptChoose = (options) => `Your job is to choose the next task to work on from the prd.yml file. **DO NOT** implement the task yet.
+	const promptChoose = (options) => `Your job is to choose the next task to work on from the prd.yml file. **DO NOT** implement the task yet, or update the prd.yml file.
 
 The following instructions should be done without interaction or asking for permission.
 
 - Decide which single task to work on next from the prd.yml file. This should
-   be the task YOU decide as the most important to work on next, not just the
-   first task in the list.
-   - Only start tasks that are in a "todo" state.
-   - You **cannot** start tasks unless they have an empty \`blockedBy\` field.
-- **Before doing anything else**, mark the task as "in-progress" by updating its
-   \`state\` in the prd.yml file.
-This prevents other people or agents from working on the same task simultaneously.${options.gitFlow.requiresGithubPr ? `
+  be the task YOU decide as the most important to work on next, not just the
+  first task in the list.
+  - Only start tasks that are in a "todo" state.
+  - You **cannot** start tasks unless they have an empty \`blockedBy\` field.${options.gitFlow.requiresGithubPr ? `
 - Check if there is an open Github PR for the chosen task. If there is, note the PR number for inclusion in the task.json file.
    - Only include "open" PRs that are not yet merged.
    - The pull request will contain the task id in the title or description.` : ""}
@@ -151768,7 +151503,7 @@ const makeExecHelpers = fnUntraced(function* (options) {
 		const handle = yield* provide(command.asEffect());
 		yield* handle.all.pipe(decodeText(), options.cliAgent.outputTransformer ? options.cliAgent.outputTransformer : identity, runForEachArray((output) => {
 			for (const chunk of output) process.stdout.write(chunk);
-			registry.update(worker.output, flow(appendAll$1(fromArrayUnsafe(output)), takeRight(constWorkerMaxOutputChunks)));
+			registry.update(worker.output, flow(appendAll(fromArrayUnsafe(output)), takeRight(constWorkerMaxOutputChunks)));
 			return void_$1;
 		}));
 		return yield* handle.exitCode;
@@ -151788,7 +151523,7 @@ const makeExecHelpers = fnUntraced(function* (options) {
 		yield* handle.all.pipe(decodeText(), options.cliAgent.outputTransformer ? options.cliAgent.outputTransformer : identity, runForEachArray((output) => {
 			lastOutputAt = nowUnsafe();
 			for (const chunk of output) process.stdout.write(chunk);
-			registry.update(worker.output, flow(appendAll$1(fromArrayUnsafe(output)), takeRight(constWorkerMaxOutputChunks)));
+			registry.update(worker.output, flow(appendAll(fromArrayUnsafe(output)), takeRight(constWorkerMaxOutputChunks)));
 			return void_$1;
 		}), raceFirst(stallTimeout));
 		return yield* handle.exitCode;
@@ -151924,11 +151659,8 @@ var Prd = class extends Service$1()("lalph/Prd", { make: gen(function* () {
 		const nextYaml = PrdIssue.arrayToYaml(sourceIssues).trim();
 		if (currentYaml === nextYaml) return;
 		yield* fs.writeFileString(prdFile, nextYaml);
-	}, scoped$1, syncSemaphore.withPermitsIfAvailable(1), withSpan("Prd.updateSync"), run$3(updateSyncHandle, { onlyIfMissing: true }));
-	yield* fs.watch(lalphDir).pipe(debounce(50), buffer({
-		capacity: 1,
-		strategy: "dropping"
-	}), runForEach((_) => clear(updateSyncHandle).pipe(andThen(ignore(sync$2)))), retry$1(forever$1), forkScoped);
+	}, scoped$1, withSpan("Prd.updateSync"), run$3(updateSyncHandle, { onlyIfMissing: true }), syncSemaphore.withPermitsIfAvailable(1));
+	yield* fs.watch(lalphDir).pipe(debounce(50), runForEach((_) => clear(updateSyncHandle).pipe(andThen(ignore(sync$2)))), retry$1(forever$1), forkScoped);
 	yield* toStreamResult(registry, currentIssuesAtom(projectId)).pipe(runForEach(updateSync), forkScoped);
 	const findById = fnUntraced(function* (issueId) {
 		return (yield* getCurrentIssues).find((i) => i.id === issueId) ?? null;
@@ -152192,6 +151924,11 @@ const run = fnUntraced(function* (options) {
 	taskId = chosenTask.id;
 	yield* prd.setChosenIssueId(taskId);
 	yield* prd.setAutoMerge(chosenTask.prd.autoMerge);
+	yield* source.updateIssue({
+		projectId,
+		issueId: taskId,
+		state: "in-progress"
+	});
 	yield* source.ensureInProgress(projectId, taskId).pipe(timeoutOrElse({
 		duration: "1 minute",
 		onTimeout: () => fail$4(new RunnerStalled())
@@ -152557,7 +152294,7 @@ const commandSource = make$35("source").pipe(withDescription("Select the issue s
 
 //#endregion
 //#region package.json
-var version = "0.3.7";
+var version = "0.3.8";
 
 //#endregion
 //#region src/commands/projects/ls.ts

package/package.json

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

package/src/Prd.ts

@@ -224,17 +224,13 @@ export class Prd extends ServiceMap.Service<
         yield* fs.writeFileString(prdFile, nextYaml)
       },
       Effect.scoped,
-      syncSemaphore.withPermitsIfAvailable(1),
       Effect.withSpan("Prd.updateSync"),
       FiberHandle.run(updateSyncHandle, { onlyIfMissing: true }),
+      syncSemaphore.withPermitsIfAvailable(1),
     )
 
     yield* fs.watch(lalphDir).pipe(
       Stream.debounce(50),
-      Stream.buffer({
-        capacity: 1,
-        strategy: "dropping",
-      }),
       Stream.runForEach((_) =>
         FiberHandle.clear(updateSyncHandle).pipe(
           Effect.andThen(Effect.ignore(sync)),

package/src/PromptGen.ts

@@ -74,25 +74,22 @@ ${JSON.stringify(PrdIssue.jsonSchema, null, 2)}
 
       const promptChoose = (options: {
         readonly gitFlow: GitFlow["Service"]
-      }) => `Your job is to choose the next task to work on from the prd.yml file. **DO NOT** implement the task yet.
+      }) => `Your job is to choose the next task to work on from the prd.yml file. **DO NOT** implement the task yet, or update the prd.yml file.
 
 The following instructions should be done without interaction or asking for permission.
 
 - Decide which single task to work on next from the prd.yml file. This should
-   be the task YOU decide as the most important to work on next, not just the
-   first task in the list.
-   - Only start tasks that are in a "todo" state.
-   - You **cannot** start tasks unless they have an empty \`blockedBy\` field.
-- **Before doing anything else**, mark the task as "in-progress" by updating its
-   \`state\` in the prd.yml file.
-This prevents other people or agents from working on the same task simultaneously.${
-        options.gitFlow.requiresGithubPr
-          ? `
+  be the task YOU decide as the most important to work on next, not just the
+  first task in the list.
+  - Only start tasks that are in a "todo" state.
+  - You **cannot** start tasks unless they have an empty \`blockedBy\` field.${
+    options.gitFlow.requiresGithubPr
+      ? `
 - Check if there is an open Github PR for the chosen task. If there is, note the PR number for inclusion in the task.json file.
    - Only include "open" PRs that are not yet merged.
    - The pull request will contain the task id in the title or description.`
-          : ""
-      }
+      : ""
+  }
 - Once you have chosen a task, save its information in a "task.json" file alongside
    the prd.yml file. Use the following format:
 

package/src/commands/root.ts

@@ -114,6 +114,11 @@ const run = Effect.fnUntraced(
     yield* prd.setChosenIssueId(taskId)
     yield* prd.setAutoMerge(chosenTask.prd.autoMerge)
 
+    yield* source.updateIssue({
+      projectId,
+      issueId: taskId,
+      state: "in-progress",
+    })
     yield* source.ensureInProgress(projectId, taskId).pipe(
       Effect.timeoutOrElse({
         duration: "1 minute",