lalph 0.2.18 → 0.2.20

package/dist/cli.mjs

@@ -7235,7 +7235,7 @@ const getOption = /* @__PURE__ */ dual(2, (self, service) => {
 * @since 4.0.0
 * @category Utils
 */
-const merge$6 = /* @__PURE__ */ dual(2, (self, that) => {
+const merge$5 = /* @__PURE__ */ dual(2, (self, that) => {
 	if (self.mapUnsafe.size === 0) return that;
 	if (that.mapUnsafe.size === 0) return self;
 	const map = new Map(self.mapUnsafe);
@@ -9229,7 +9229,7 @@ const servicesWith$1 = (f) => withFiber$1((fiber) => f(fiber.services));
 /** @internal */
 const provideServices$1 = /* @__PURE__ */ dual(2, (self, services) => {
 	if (effectIsExit(self)) return self;
-	return updateServices$1(self, merge$6(services));
+	return updateServices$1(self, merge$5(services));
 });
 /** @internal */
 const provideService$1 = function() {
@@ -12030,38 +12030,6 @@ const mergeAllEffect = (layers, memoMap, scope) => {
 * @category zipping
 */
 const mergeAll = (...layers) => fromBuild((memoMap, scope) => mergeAllEffect(layers, memoMap, scope));
-/**
-* Merges this layer with the specified layer concurrently, producing a new layer with combined input and output types.
-*
-* This is a binary version of `mergeAll` that merges exactly two layers or one layer with an array of layers.
-* The layers are built concurrently and their outputs are combined.
-*
-* @example
-* ```ts
-* import { Effect, Layer, ServiceMap } from "effect"
-*
-* class Database extends ServiceMap.Service<Database, {
-*   readonly query: (sql: string) => Effect.Effect<string>
-* }>()("Database") {}
-*
-* class Logger extends ServiceMap.Service<Logger, {
-*   readonly log: (msg: string) => Effect.Effect<void>
-* }>()("Logger") {}
-*
-* const dbLayer = Layer.succeed(Database)({
-*   query: (sql: string) => Effect.succeed("result")
-* })
-* const loggerLayer = Layer.succeed(Logger)({
-*   log: (msg: string) => Effect.sync(() => console.log(msg))
-* })
-*
-* const mergedLayer = Layer.merge(dbLayer, loggerLayer)
-* ```
-*
-* @since 2.0.0
-* @category zipping
-*/
-const merge$5 = /* @__PURE__ */ dual(2, (self, that) => mergeAll(self, ...Array.isArray(that) ? that : [that]));
 const provideWith = (self, that, f) => fromBuild((memoMap, scope) => flatMap$4(Array.isArray(that) ? mergeAllEffect(that, memoMap, scope) : that.build(memoMap, scope), (context) => self.build(memoMap, scope).pipe(provideServices$1(context), map$11((merged) => f(merged, context)))));
 /**
 * Feeds the output services of this builder into the input of the specified
@@ -12204,7 +12172,7 @@ const provide$3 = /* @__PURE__ */ dual(2, (self, that) => provideWith(self, that
 * @since 2.0.0
 * @category utils
 */
-const provideMerge = /* @__PURE__ */ dual(2, (self, that) => provideWith(self, that, (self, that) => merge$6(that, self)));
+const provideMerge = /* @__PURE__ */ dual(2, (self, that) => provideWith(self, that, (self, that) => merge$5(that, self)));
 /**
 * Constructs a layer dynamically based on the output of this layer.
 *
@@ -51194,7 +51162,7 @@ const TypeId$29 = "~effect/Cache";
 */
 const makeWith$1 = (options) => servicesWith$1((services) => {
 	const self = Object.create(Proto$14);
-	self.lookup = (key) => updateServices$1(options.lookup(key), (input) => merge$6(services, input));
+	self.lookup = (key) => updateServices$1(options.lookup(key), (input) => merge$5(services, input));
 	self.map = make$45();
 	self.capacity = options.capacity;
 	self.timeToLive = options.timeToLive ? (exit, key) => fromDurationInputUnsafe(options.timeToLive(exit, key)) : defaultTimeToLive;
@@ -59031,7 +58999,7 @@ const SpanNameGenerator$1 = /* @__PURE__ */ Reference("effect/http/HttpClient/Sp
 /**
 * @since 4.0.0
 */
-const layerMergedServices = (effect) => effect$1(HttpClient)(servicesWith((services) => map$8(effect, (client) => transformResponse(client, updateServices((input) => merge$6(services, input))))));
+const layerMergedServices = (effect) => effect$1(HttpClient)(servicesWith((services) => map$8(effect, (client) => transformResponse(client, updateServices((input) => merge$5(services, input))))));
 const responseRegistry = /* @__PURE__ */ (() => {
 	if ("FinalizationRegistry" in globalThis && globalThis.FinalizationRegistry) {
 		const registry = /* @__PURE__ */ new FinalizationRegistry((controller) => {
@@ -60328,7 +60296,7 @@ const fromWebSocket = (acquire, options) => withFiber((fiber) => {
 		latch.openUnsafe();
 		if (opts?.onOpen) yield* opts.onOpen;
 		return yield* join(fiberSet).pipe(catchFilter(SocketCloseError.filterClean((_) => !closeCodeIsError(_)), (_) => void_$1));
-	})).pipe(updateServices((input) => merge$6(acquireContext, input)), ensuring$2(sync(() => {
+	})).pipe(updateServices((input) => merge$5(acquireContext, input)), ensuring$2(sync(() => {
 		latch.closeUnsafe();
 		currentWS = void 0;
 	})));
@@ -150368,32 +150336,41 @@ const PollResponse = Union([TokenResponse, PollErrorResponse]);
 
 //#endregion
 //#region src/domain/GithubComment.ts
-var Author = class extends Class("github/Author")({ login: String$1 }) {};
-var Comment = class extends Class("github/Comment")({
+var Author = class extends Class("Author")({ login: String$1 }) {};
+var Comment = class extends Class("Comment")({
 	id: String$1,
 	body: String$1,
-	author: Author
+	author: Author,
+	createdAt: String$1
 }) {};
-var CommentsEdge = class extends Class("github/CommentsEdge")({ node: Comment }) {};
-var PullRequestComments = class extends Class("PullRequestComments")({ edges: Array$1(CommentsEdge) }) {};
-var PullRequest = class extends Class("github/PullRequest")({
+var PullRequestComments = class extends Class("PullRequestComments")({ nodes: Array$1(Comment) }) {};
+var PullRequest = class extends Class("PullRequest")({
 	url: String$1,
+	reviewDecision: Null,
+	reviews: suspend(() => Reviews),
 	reviewThreads: suspend(() => ReviewThreads),
 	comments: PullRequestComments
 }) {};
-var Repository = class extends Class("github/Repository")({ pullRequest: PullRequest }) {};
-var Data = class extends Class("github/Data")({ repository: Repository }) {};
-var CommentsData = class extends Class("github/CommentsData")({ data: Data }) {};
-var ReviewComment = class extends Class("github/ReviewComment")({
+var Repository = class extends Class("Repository")({ pullRequest: PullRequest }) {};
+var Data = class extends Class("Data")({ repository: Repository }) {};
+var GithubPullRequestData = class extends Class("GithubPullRequestData")({ data: Data }) {};
+var Review = class extends Class("Review")({
+	id: String$1,
+	author: Author,
+	body: String$1
+}) {};
+var Reviews = class extends Class("Reviews")({ nodes: Array$1(Review) }) {};
+var ReviewComment = class extends Class("ReviewComment")({
 	id: String$1,
 	author: Author,
 	body: String$1,
 	path: String$1,
-	originalLine: NullOr(Number$1),
-	diffHunk: String$1
+	originalLine: Number$1,
+	diffHunk: String$1,
+	createdAt: String$1
 }) {};
-var NodeComments = class extends Class("github/NodeComments")({ nodes: Array$1(ReviewComment) }) {};
-var ReviewThreadNode = class extends Class("github/ReviewThreadNode")({
+var NodeComments = class extends Class("NodeComments")({ nodes: Array$1(ReviewComment) }) {};
+var ReviewThreadsNode = class extends Class("ReviewThreadsNode")({
 	isCollapsed: Boolean$2,
 	isOutdated: Boolean$2,
 	isResolved: Boolean$2,
@@ -150402,8 +150379,7 @@ var ReviewThreadNode = class extends Class("github/ReviewThreadNode")({
 	commentNodes = this.comments.nodes;
 	shouldDisplayThread = !this.isCollapsed && !this.isOutdated;
 };
-var ReviewThreadsEdge = class extends Class("ReviewThreadsEdge")({ node: ReviewThreadNode }) {};
-var ReviewThreads = class extends Class("github/ReviewThreads")({ edges: Array$1(ReviewThreadsEdge) }) {};
+var ReviewThreads = class extends Class("ReviewThreads")({ nodes: Array$1(ReviewThreadsNode) }) {};
 
 //#endregion
 //#region src/Github/Cli.ts
@@ -150413,15 +150389,16 @@ var GithubCli = class extends Service$1()("lalph/Github/Cli", { make: gen(functi
 		onNone: () => fail$4(new GithubCliRepoNotFound()),
 		onSome: (value) => succeed$1(value)
 	}))))).split("/");
-	const reviewComments = (pr) => make$23`gh api graphql -f owner=${owner} -f repo=${repo} -F pr=${pr} -f query=${githubReviewCommentsQuery}`.pipe(string, flatMap$2(decodeEffect(CommentsFromJson)), map$8((data) => {
+	const reviewComments = (pr) => make$23`gh api graphql -f owner=${owner} -f repo=${repo} -F pr=${pr} -f query=${githubReviewCommentsQuery}`.pipe(string, flatMap$2(decodeEffect(PullRequestDataFromJson)), map$8((data) => {
 		return {
-			comments: data.data.repository.pullRequest.comments.edges.map((edge) => edge.node),
-			reviewThreads: data.data.repository.pullRequest.reviewThreads.edges.map((edge) => edge.node)
+			comments: data.data.repository.pullRequest.comments.nodes.filter((c) => !c.author.login.startsWith("github")),
+			reviews: data.data.repository.pullRequest.reviews.nodes.filter((r) => r.body.trim().length > 0),
+			reviewThreads: data.data.repository.pullRequest.reviewThreads.nodes
 		};
 	}), provideService(ChildProcessSpawner, spawner));
-	const prFeedbackMd = (pr) => reviewComments(pr).pipe(map$8(({ comments, reviewThreads }) => {
+	const prFeedbackMd = (pr) => reviewComments(pr).pipe(map$8(({ comments, reviewThreads, reviews }) => {
 		const eligibleReviewThreads = reviewThreads.filter((thread) => thread.shouldDisplayThread);
-		if (comments.length === 0 && eligibleReviewThreads.length === 0) return `No review comments found.`;
+		if (comments.length === 0 && eligibleReviewThreads.length === 0 && reviews.length === 0) return `No review comments found.`;
 		let content = `# PR feedback
 
 Comments are rendered in XML format.`;
@@ -150432,6 +150409,18 @@ Comments are rendered in XML format.`;
 ## Review Comments
 
 ${reviewCommentsMd}`;
+		}
+		if (reviews.length > 0) {
+			const reviewsXml = reviews.map((review) => `<review author="${review.author.login}">
+  <body><![CDATA[${review.body}]]></body>
+</review>`).join("\n");
+			content += `
+
+## Reviews
+
+<reviews>
+${reviewsXml}
+</reviews>`;
 		}
 		if (comments.length > 0) {
 			const generalCommentsXml = comments.map((comment) => renderGeneralComment(comment)).join("\n");
@@ -150470,46 +150459,55 @@ const renderReviewComments = (comment, followup) => `<comment author="${comment.
 const renderGeneralComment = (comment) => `  <comment author="${comment.author.login}">
     <body><![CDATA[${comment.body}]]></body>
   </comment>`;
-const CommentsFromJson = fromJsonString(CommentsData);
+const PullRequestDataFromJson = fromJsonString(GithubPullRequestData);
 const githubReviewCommentsQuery = `
-  query FetchPRComments($owner: String!, $repo: String!, $pr: Int!) {
-    repository(owner: $owner, name: $repo) {
-      pullRequest(number: $pr) {
-        url
-        reviewDecision
-        reviewThreads(first: 100) {
-          edges {
-            node {
-              isCollapsed
-              isOutdated
-              isResolved
-              comments(first: 100) {
-                nodes {
-                  id
-                  author { login }
-                  body
-                  path
-                  originalLine
-                  diffHunk
-                  createdAt
-                }
-              }
-            }
+query FetchPRComments($owner: String!, $repo: String!, $pr: Int!) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $pr) {
+      url
+      reviewDecision
+      reviews(first: 100) {
+        nodes {
+          id
+          author {
+            login
           }
+          body
         }
-        comments(first: 100) {
-          edges {
-            node {
+      }
+      reviewThreads(first: 100) {
+        nodes {
+          isCollapsed
+          isOutdated
+          isResolved
+          comments(first: 100) {
+            nodes {
               id
+              author {
+                login
+              }
               body
-              author { login }
+              path
+              originalLine
+              diffHunk
               createdAt
             }
           }
         }
       }
+      comments(first: 100) {
+        nodes {
+          id
+          body
+          author {
+            login
+          }
+          createdAt
+        }
+      }
     }
   }
+}
 `;
 
 //#endregion
@@ -151033,8 +151031,13 @@ permission.
 5. If any specifications need updating based on your new understanding, update them.
 
 ${prdNotes(options)}`;
-	const planPrompt = (options) => `1. Ask the user for the idea / request, then your job is to create a detailed
-   specification to fulfill the request and save it as a file.
+	const planPrompt = (options) => `<request><![CDATA[
+${options.plan}
+]]></request>
+
+## Instructions
+
+1. Your job is to create a detailed specification to fulfill the request and save it as a file.
    First do some research to understand the request, then interview the user
    to gather all the necessary requirements and details for the specification.
    - If the user asks you to update an existing specification, find the relevant
@@ -152090,6 +152093,41 @@ const commandPlanTasks = make$35("tasks", { specificationPath }).pipe(withDescri
 	Worktree.layer.pipe(provide$3(layerProjectIdPrompt))
 ]))));
 
+//#endregion
+//#region src/shared/config.ts
+const configEditor = string$1("LALPH_EDITOR").pipe(orElse(() => string$1("EDITOR")), map$5(parseCommand), withDefault$3(() => ["nano"]));
+
+//#endregion
+//#region src/Editor.ts
+var Editor = class extends Service$1()("lalph/Editor", { make: gen(function* () {
+	const fs = yield* FileSystem;
+	const editor = yield* configEditor;
+	const spawner = yield* ChildProcessSpawner;
+	const edit = (path) => make$23(editor[0], [...editor.slice(1), path], {
+		stdin: "inherit",
+		stdout: "inherit",
+		stderr: "inherit"
+	}).pipe(exitCode, provideService(ChildProcessSpawner, spawner), orDie$2);
+	return {
+		edit,
+		editTemp: fnUntraced(function* (options) {
+			const initialContent = options.initialContent ?? "";
+			const file = yield* fs.makeTempFileScoped({ suffix: options.suffix ?? ".txt" });
+			if (initialContent) yield* fs.writeFileString(file, initialContent);
+			if ((yield* make$23(editor[0], [...editor.slice(1), file], {
+				stdin: "inherit",
+				stdout: "inherit",
+				stderr: "inherit"
+			}).pipe(exitCode)) !== 0) return yield* new NoSuchElementError();
+			const content = (yield* fs.readFileString(file)).trim();
+			if (content === initialContent) return yield* new NoSuchElementError();
+			return content;
+		}, scoped$1, provideService(ChildProcessSpawner, spawner), option$1)
+	};
+}) }) {
+	static layer = effect$1(this, this.make).pipe(provide$3(PlatformServices));
+};
+
 //#endregion
 //#region src/commands/plan.ts
 const dangerous = boolean("dangerous").pipe(withAlias("d"), withDescription$1("Enable dangerous mode (skip permission prompts) during plan generation"));
@@ -152098,30 +152136,39 @@ const commandPlan = make$35("plan", {
 	dangerous,
 	withNewProject
 }).pipe(withDescription("Iterate on an issue plan and create PRD tasks"), withHandler(fnUntraced(function* ({ dangerous, withNewProject }) {
+	const thePlan = yield* (yield* Editor).editTemp({ suffix: ".md" });
+	if (isNone(thePlan)) return;
 	const project = withNewProject ? yield* addOrUpdateProject() : yield* selectProject;
 	const { specsDirectory } = yield* commandRoot;
 	const commandPrefix = yield* getCommandPrefix;
 	yield* plan({
+		plan: thePlan.value,
 		specsDirectory,
 		targetBranch: project.targetBranch,
 		commandPrefix,
 		dangerous
 	}).pipe(provideService(CurrentProjectId, project.id));
-}, provide$1([Settings.layer, CurrentIssueSource.layer]))), withSubcommands([commandPlanTasks]));
+}, provide$1([
+	Settings.layer,
+	CurrentIssueSource.layer,
+	Editor.layer
+]))), withSubcommands([commandPlanTasks]));
 const plan = fnUntraced(function* (options) {
 	const fs = yield* FileSystem;
 	const pathService = yield* Path$1;
 	const worktree = yield* Worktree;
 	const cliAgent = yield* getOrSelectCliAgent;
 	yield* agentPlanner({
+		plan: options.plan,
 		specsDirectory: options.specsDirectory,
 		commandPrefix: options.commandPrefix,
 		dangerous: options.dangerous,
 		cliAgent
 	});
+	const planDetails = yield* pipe(fs.readFileString(pathService.join(worktree.directory, ".lalph", "plan.json")), flatMap$2(decodeEffect(PlanDetails)), mapError$2(() => new SpecNotFound()));
 	yield* log$1("Converting specification into tasks");
 	yield* agentTasker({
-		specificationPath: (yield* pipe(fs.readFileString(pathService.join(worktree.directory, ".lalph", "plan.json")), flatMap$2(decodeEffect(PlanDetails)))).specification,
+		specificationPath: planDetails.specification,
 		specsDirectory: options.specsDirectory,
 		commandPrefix: options.commandPrefix,
 		cliAgent
@@ -152130,16 +152177,15 @@ const plan = fnUntraced(function* (options) {
 }, scoped$1, provide$1([
 	PromptGen.layer,
 	Prd.layerProvided,
-	Worktree.layer.pipe(provide$3(layerProjectIdPrompt)),
+	Worktree.layer,
 	Settings.layer,
 	CurrentIssueSource.layer
 ]));
+var SpecNotFound = class extends TaggedError("SpecNotFound") {
+	message = "The AI agent failed to produce a specification.";
+};
 const PlanDetails = fromJsonString(Struct({ specification: String$1 }));
 
-//#endregion
-//#region src/shared/config.ts
-const configEditor = string$1("LALPH_EDITOR").pipe(orElse(() => string$1("EDITOR")), map$5(parseCommand), withDefault$3(() => ["nano"]));
-
 //#endregion
 //#region src/commands/issue.ts
 const issueTemplate = `---
@@ -152160,19 +152206,13 @@ const FrontMatterSchema = toCodecJson(Struct({
 }));
 const handler$1 = flow(withHandler(fnUntraced(function* () {
 	const source = yield* IssueSource;
-	const fs = yield* FileSystem;
 	const projectId = yield* CurrentProjectId;
-	const tempFile = yield* fs.makeTempFileScoped({ suffix: ".md" });
-	const editor = yield* configEditor;
-	yield* fs.writeFileString(tempFile, issueTemplate);
-	if ((yield* make$23(editor[0], [...editor.slice(1), tempFile], {
-		stdin: "inherit",
-		stdout: "inherit",
-		stderr: "inherit"
-	}).pipe(exitCode)) !== 0) return;
-	const content = yield* fs.readFileString(tempFile);
-	if (content.trim() === issueTemplate.trim()) return;
-	const lines = content.split("\n");
+	const content = yield* (yield* Editor).editTemp({
+		suffix: ".md",
+		initialContent: issueTemplate
+	});
+	if (isNone(content)) return;
+	const lines = content.value.split("\n");
 	const yamlLines = [];
 	let descriptionStartIndex = 0;
 	for (let i = 0; i < lines.length; i++) {
@@ -152195,7 +152235,7 @@ const handler$1 = flow(withHandler(fnUntraced(function* () {
 	}));
 	console.log(`Created issue with ID: ${created.id}`);
 	console.log(`URL: ${created.url}`);
-}, scoped$1)), provide(merge$5(layerProjectIdPrompt, CurrentIssueSource.layer)));
+}, scoped$1)), provide(mergeAll(layerProjectIdPrompt, CurrentIssueSource.layer, Editor.layer)));
 const commandIssue = make$35("issue").pipe(withDescription("Create a new issue in the selected issue source"), handler$1);
 const commandIssueAlias = make$35("i").pipe(withDescription("Alias for 'issue' command"), handler$1);
 
@@ -152203,14 +152243,8 @@ const commandIssueAlias = make$35("i").pipe(withDescription("Alias for 'issue' c
 //#region src/commands/edit.ts
 const handler = withHandler(fnUntraced(function* () {
 	const prd = yield* Prd;
-	const editor = yield* configEditor;
-	yield* make$23(editor[0], [...editor.slice(1), prd.path], {
-		extendEnv: true,
-		stdin: "inherit",
-		stdout: "inherit",
-		stderr: "inherit"
-	}).pipe(exitCode);
-}, scoped$1, provide$1(Prd.layerLocalProvided.pipe(provideMerge(layerProjectIdPrompt)))));
+	yield* (yield* Editor).edit(prd.path);
+}, provide$1([Prd.layerLocalProvided.pipe(provideMerge(layerProjectIdPrompt)), Editor.layer])));
 const commandEdit = make$35("edit").pipe(withDescription("Open the prd.yml file in your editor"), handler);
 const commandEditAlias = make$35("e").pipe(withDescription("Alias for 'edit' command"), handler);
 
@@ -152220,7 +152254,7 @@ const commandSource = make$35("source").pipe(withDescription("Select the issue s
 
 //#endregion
 //#region package.json
-var version = "0.2.18";
+var version = "0.2.20";
 
 //#endregion
 //#region src/commands/projects/ls.ts

package/package.json

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

package/src/Agents/planner.ts

@@ -5,6 +5,7 @@ import { Worktree } from "../Worktree.ts"
 import type { CliAgent } from "../domain/CliAgent.ts"
 
 export const agentPlanner = Effect.fnUntraced(function* (options: {
+  readonly plan: string
   readonly specsDirectory: string
   readonly commandPrefix: (
     command: ChildProcess.Command,

package/src/Editor.ts

@@ -0,0 +1,66 @@
+import { Cause, Effect, FileSystem, Layer, ServiceMap } from "effect"
+import { configEditor } from "./shared/config.ts"
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
+import { PlatformServices } from "./shared/platform.ts"
+
+export class Editor extends ServiceMap.Service<Editor>()("lalph/Editor", {
+  make: Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem
+    const editor = yield* configEditor
+    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
+
+    const edit = (path: string) =>
+      ChildProcess.make(editor[0]!, [...editor.slice(1), path], {
+        stdin: "inherit",
+        stdout: "inherit",
+        stderr: "inherit",
+      }).pipe(
+        ChildProcess.exitCode,
+        Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
+        Effect.orDie,
+      )
+
+    const editTemp = Effect.fnUntraced(
+      function* (options: {
+        readonly initialContent?: string
+        readonly suffix?: string
+      }) {
+        const initialContent = options.initialContent ?? ""
+        const file = yield* fs.makeTempFileScoped({
+          suffix: options.suffix ?? ".txt",
+        })
+        if (initialContent) {
+          yield* fs.writeFileString(file, initialContent)
+        }
+
+        const exitCode = yield* ChildProcess.make(
+          editor[0]!,
+          [...editor.slice(1), file],
+          {
+            stdin: "inherit",
+            stdout: "inherit",
+            stderr: "inherit",
+          },
+        ).pipe(ChildProcess.exitCode)
+
+        if (exitCode !== 0) {
+          return yield* new Cause.NoSuchElementError()
+        }
+        const content = (yield* fs.readFileString(file)).trim()
+        if (content === initialContent) {
+          return yield* new Cause.NoSuchElementError()
+        }
+        return content
+      },
+      Effect.scoped,
+      Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
+      Effect.option,
+    )
+
+    return { edit, editTemp } as const
+  }),
+}) {
+  static layer = Layer.effect(this, this.make).pipe(
+    Layer.provide(PlatformServices),
+  )
+}

package/src/Github/Cli.ts

@@ -10,9 +10,9 @@ import {
 } from "effect"
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
 import {
-  CommentsData,
-  ReviewComment,
   Comment,
+  GithubPullRequestData,
+  ReviewComment,
 } from "../domain/GithubComment.ts"
 
 export class GithubCli extends ServiceMap.Service<GithubCli>()(
@@ -41,17 +41,19 @@ export class GithubCli extends ServiceMap.Service<GithubCli>()(
       const reviewComments = (pr: number) =>
         ChildProcess.make`gh api graphql -f owner=${owner} -f repo=${repo} -F pr=${pr} -f query=${githubReviewCommentsQuery}`.pipe(
           ChildProcess.string,
-          Effect.flatMap(Schema.decodeEffect(CommentsFromJson)),
+          Effect.flatMap(Schema.decodeEffect(PullRequestDataFromJson)),
           Effect.map((data) => {
             const comments =
-              data.data.repository.pullRequest.comments.edges.map(
-                (edge) => edge.node,
+              data.data.repository.pullRequest.comments.nodes.filter(
+                (c) => !c.author.login.startsWith("github"),
               )
-            const reviewThreads =
-              data.data.repository.pullRequest.reviewThreads.edges.map(
-                (edge) => edge.node,
+            const reviews =
+              data.data.repository.pullRequest.reviews.nodes.filter(
+                (r) => r.body.trim().length > 0,
               )
-            return { comments, reviewThreads } as const
+            const reviewThreads =
+              data.data.repository.pullRequest.reviewThreads.nodes
+            return { comments, reviews, reviewThreads } as const
           }),
           Effect.provideService(
             ChildProcessSpawner.ChildProcessSpawner,
@@ -61,12 +63,16 @@ export class GithubCli extends ServiceMap.Service<GithubCli>()(
 
       const prFeedbackMd = (pr: number) =>
         reviewComments(pr).pipe(
-          Effect.map(({ comments, reviewThreads }) => {
+          Effect.map(({ comments, reviewThreads, reviews }) => {
             const eligibleReviewThreads = reviewThreads.filter(
               (thread) => thread.shouldDisplayThread,
             )
 
-            if (comments.length === 0 && eligibleReviewThreads.length === 0) {
+            if (
+              comments.length === 0 &&
+              eligibleReviewThreads.length === 0 &&
+              reviews.length === 0
+            ) {
               return `No review comments found.`
             }
 
@@ -90,6 +96,23 @@ Comments are rendered in XML format.`
 ${reviewCommentsMd}`
             }
 
+            if (reviews.length > 0) {
+              const reviewsXml = reviews
+                .map(
+                  (review) => `<review author="${review.author.login}">
+  <body><![CDATA[${review.body}]]></body>
+</review>`,
+                )
+                .join("\n")
+              content += `
+
+## Reviews
+
+<reviews>
+${reviewsXml}
+</reviews>`
+            }
+
             if (comments.length > 0) {
               const generalCommentsXml = comments
                 .map((comment) => renderGeneralComment(comment))
@@ -155,45 +178,54 @@ const renderGeneralComment = (
 
 // Schema definitions and GraphQL query
 
-const CommentsFromJson = Schema.fromJsonString(CommentsData)
+const PullRequestDataFromJson = Schema.fromJsonString(GithubPullRequestData)
 
 const githubReviewCommentsQuery = `
-  query FetchPRComments($owner: String!, $repo: String!, $pr: Int!) {
-    repository(owner: $owner, name: $repo) {
-      pullRequest(number: $pr) {
-        url
-        reviewDecision
-        reviewThreads(first: 100) {
-          edges {
-            node {
-              isCollapsed
-              isOutdated
-              isResolved
-              comments(first: 100) {
-                nodes {
-                  id
-                  author { login }
-                  body
-                  path
-                  originalLine
-                  diffHunk
-                  createdAt
-                }
-              }
-            }
+query FetchPRComments($owner: String!, $repo: String!, $pr: Int!) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $pr) {
+      url
+      reviewDecision
+      reviews(first: 100) {
+        nodes {
+          id
+          author {
+            login
           }
+          body
         }
-        comments(first: 100) {
-          edges {
-            node {
+      }
+      reviewThreads(first: 100) {
+        nodes {
+          isCollapsed
+          isOutdated
+          isResolved
+          comments(first: 100) {
+            nodes {
               id
+              author {
+                login
+              }
               body
-              author { login }
+              path
+              originalLine
+              diffHunk
               createdAt
             }
           }
         }
       }
+      comments(first: 100) {
+        nodes {
+          id
+          body
+          author {
+            login
+          }
+          createdAt
+        }
+      }
     }
   }
+}
 `

package/src/PromptGen.ts

@@ -233,9 +233,15 @@ permission.
 ${prdNotes(options)}`
 
       const planPrompt = (options: {
+        readonly plan: string
         readonly specsDirectory: string
-      }) => `1. Ask the user for the idea / request, then your job is to create a detailed
-   specification to fulfill the request and save it as a file.
+      }) => `<request><![CDATA[
+${options.plan}
+]]></request>
+
+## Instructions
+
+1. Your job is to create a detailed specification to fulfill the request and save it as a file.
    First do some research to understand the request, then interview the user
    to gather all the necessary requirements and details for the specification.
    - If the user asks you to update an existing specification, find the relevant

package/src/commands/edit.ts

@@ -1,27 +1,20 @@
 import { Command } from "effect/unstable/cli"
 import { Effect, Layer } from "effect"
-import { ChildProcess } from "effect/unstable/process"
 import { Prd } from "../Prd.ts"
-import { configEditor } from "../shared/config.ts"
 import { layerProjectIdPrompt } from "../Projects.ts"
+import { Editor } from "../Editor.ts"
 
 const handler = Command.withHandler(
   Effect.fnUntraced(
     function* () {
       const prd = yield* Prd
-      const editor = yield* configEditor
-
-      yield* ChildProcess.make(editor[0]!, [...editor.slice(1), prd.path], {
-        extendEnv: true,
-        stdin: "inherit",
-        stdout: "inherit",
-        stderr: "inherit",
-      }).pipe(ChildProcess.exitCode)
+      const editor = yield* Editor
+      yield* editor.edit(prd.path)
     },
-    Effect.scoped,
-    Effect.provide(
+    Effect.provide([
       Prd.layerLocalProvided.pipe(Layer.provideMerge(layerProjectIdPrompt)),
-    ),
+      Editor.layer,
+    ]),
   ),
 )
 

package/src/commands/issue.ts

@@ -1,13 +1,12 @@
 import { Command } from "effect/unstable/cli"
 import { CurrentIssueSource } from "../CurrentIssueSource.ts"
-import { Effect, FileSystem, flow, Layer, Schema } from "effect"
+import { Effect, flow, Layer, Option, Schema } from "effect"
 import { IssueSource } from "../IssueSource.ts"
-import { ChildProcess } from "effect/unstable/process"
 import { PrdIssue } from "../domain/PrdIssue.ts"
 import * as Yaml from "yaml"
-import { configEditor } from "../shared/config.ts"
 import { CurrentProjectId } from "../Settings.ts"
 import { layerProjectIdPrompt } from "../Projects.ts"
+import { Editor } from "../Editor.ts"
 
 const issueTemplate = `---
 title: Issue Title
@@ -33,31 +32,18 @@ const handler = flow(
   Command.withHandler(
     Effect.fnUntraced(function* () {
       const source = yield* IssueSource
-      const fs = yield* FileSystem.FileSystem
       const projectId = yield* CurrentProjectId
-      const tempFile = yield* fs.makeTempFileScoped({
+      const editor = yield* Editor
+
+      const content = yield* editor.editTemp({
         suffix: ".md",
+        initialContent: issueTemplate,
       })
-      const editor = yield* configEditor
-      yield* fs.writeFileString(tempFile, issueTemplate)
-
-      const exitCode = yield* ChildProcess.make(
-        editor[0]!,
-        [...editor.slice(1), tempFile],
-        {
-          stdin: "inherit",
-          stdout: "inherit",
-          stderr: "inherit",
-        },
-      ).pipe(ChildProcess.exitCode)
-      if (exitCode !== 0) return
-
-      const content = yield* fs.readFileString(tempFile)
-      if (content.trim() === issueTemplate.trim()) {
+      if (Option.isNone(content)) {
         return
       }
 
-      const lines = content.split("\n")
+      const lines = content.value.split("\n")
       const yamlLines: string[] = []
       let descriptionStartIndex = 0
       for (let i = 0; i < lines.length; i++) {
@@ -93,7 +79,13 @@ const handler = flow(
       console.log(`URL: ${created.url}`)
     }, Effect.scoped),
   ),
-  Command.provide(Layer.merge(layerProjectIdPrompt, CurrentIssueSource.layer)),
+  Command.provide(
+    Layer.mergeAll(
+      layerProjectIdPrompt,
+      CurrentIssueSource.layer,
+      Editor.layer,
+    ),
+  ),
 )
 
 export const commandIssue = Command.make("issue").pipe(

package/src/commands/plan.ts

@@ -1,13 +1,4 @@
-import {
-  Data,
-  Effect,
-  FileSystem,
-  Layer,
-  Option,
-  Path,
-  pipe,
-  Schema,
-} from "effect"
+import { Data, Effect, FileSystem, Option, Path, pipe, Schema } from "effect"
 import { PromptGen } from "../PromptGen.ts"
 import { Prd } from "../Prd.ts"
 import { Worktree } from "../Worktree.ts"
@@ -17,14 +8,11 @@ import { Command, Flag } from "effect/unstable/cli"
 import { CurrentIssueSource } from "../CurrentIssueSource.ts"
 import { commandRoot } from "./root.ts"
 import { CurrentProjectId, Settings } from "../Settings.ts"
-import {
-  addOrUpdateProject,
-  layerProjectIdPrompt,
-  selectProject,
-} from "../Projects.ts"
+import { addOrUpdateProject, selectProject } from "../Projects.ts"
 import { agentPlanner } from "../Agents/planner.ts"
 import { agentTasker } from "../Agents/tasker.ts"
 import { commandPlanTasks } from "./plan/tasks.ts"
+import { Editor } from "../Editor.ts"
 
 const dangerous = Flag.boolean("dangerous").pipe(
   Flag.withAlias("d"),
@@ -46,25 +34,36 @@ export const commandPlan = Command.make("plan", {
   Command.withHandler(
     Effect.fnUntraced(
       function* ({ dangerous, withNewProject }) {
+        const editor = yield* Editor
+
+        const thePlan = yield* editor.editTemp({
+          suffix: ".md",
+        })
+        if (Option.isNone(thePlan)) return
+
         const project = withNewProject
           ? yield* addOrUpdateProject()
           : yield* selectProject
         const { specsDirectory } = yield* commandRoot
         const commandPrefix = yield* getCommandPrefix
+
         yield* plan({
+          plan: thePlan.value,
           specsDirectory,
           targetBranch: project.targetBranch,
           commandPrefix,
           dangerous,
         }).pipe(Effect.provideService(CurrentProjectId, project.id))
       },
-      Effect.provide([Settings.layer, CurrentIssueSource.layer]),
+      Effect.provide([Settings.layer, CurrentIssueSource.layer, Editor.layer]),
     ),
   ),
   Command.withSubcommands([commandPlanTasks]),
 )
+
 const plan = Effect.fnUntraced(
   function* (options: {
+    readonly plan: string
     readonly specsDirectory: string
     readonly targetBranch: Option.Option<string>
     readonly commandPrefix: (
@@ -75,23 +74,27 @@ const plan = Effect.fnUntraced(
     const fs = yield* FileSystem.FileSystem
     const pathService = yield* Path.Path
     const worktree = yield* Worktree
+
     const cliAgent = yield* getOrSelectCliAgent
 
     yield* agentPlanner({
+      plan: options.plan,
       specsDirectory: options.specsDirectory,
       commandPrefix: options.commandPrefix,
       dangerous: options.dangerous,
       cliAgent,
     })
 
-    yield* Effect.log("Converting specification into tasks")
     const planDetails = yield* pipe(
       fs.readFileString(
         pathService.join(worktree.directory, ".lalph", "plan.json"),
       ),
       Effect.flatMap(Schema.decodeEffect(PlanDetails)),
+      Effect.mapError(() => new SpecNotFound()),
     )
 
+    yield* Effect.log("Converting specification into tasks")
+
     yield* agentTasker({
       specificationPath: planDetails.specification,
       specsDirectory: options.specsDirectory,
@@ -114,7 +117,7 @@ const plan = Effect.fnUntraced(
   Effect.provide([
     PromptGen.layer,
     Prd.layerProvided,
-    Worktree.layer.pipe(Layer.provide(layerProjectIdPrompt)),
+    Worktree.layer,
     Settings.layer,
     CurrentIssueSource.layer,
   ]),

package/src/domain/GithubComment.ts

@@ -1,62 +1,70 @@
 import * as S from "effect/Schema"
 
-export class Author extends S.Class<Author>("github/Author")({
+export class Author extends S.Class<Author>("Author")({
   login: S.String,
 }) {}
 
-export class Comment extends S.Class<Comment>("github/Comment")({
+export class Comment extends S.Class<Comment>("Comment")({
   id: S.String,
   body: S.String,
   author: Author,
-  // createdAt: S.String,
-}) {}
-
-export class CommentsEdge extends S.Class<CommentsEdge>("github/CommentsEdge")({
-  node: Comment,
+  createdAt: S.String,
 }) {}
 
 export class PullRequestComments extends S.Class<PullRequestComments>(
   "PullRequestComments",
 )({
-  edges: S.Array(CommentsEdge),
+  nodes: S.Array(Comment),
 }) {}
 
-export class PullRequest extends S.Class<PullRequest>("github/PullRequest")({
+export class PullRequest extends S.Class<PullRequest>("PullRequest")({
   url: S.String,
+  reviewDecision: S.Null,
+  reviews: S.suspend(() => Reviews),
   reviewThreads: S.suspend(() => ReviewThreads),
   comments: PullRequestComments,
 }) {}
 
-export class Repository extends S.Class<Repository>("github/Repository")({
+export class Repository extends S.Class<Repository>("Repository")({
   pullRequest: PullRequest,
 }) {}
 
-export class Data extends S.Class<Data>("github/Data")({
+export class Data extends S.Class<Data>("Data")({
   repository: Repository,
 }) {}
 
-export class CommentsData extends S.Class<CommentsData>("github/CommentsData")({
+export class GithubPullRequestData extends S.Class<GithubPullRequestData>(
+  "GithubPullRequestData",
+)({
   data: Data,
 }) {}
 
-export class ReviewComment extends S.Class<ReviewComment>(
-  "github/ReviewComment",
-)({
+export class Review extends S.Class<Review>("Review")({
+  id: S.String,
+  author: Author,
+  body: S.String,
+}) {}
+
+export class Reviews extends S.Class<Reviews>("Reviews")({
+  nodes: S.Array(Review),
+}) {}
+
+export class ReviewComment extends S.Class<ReviewComment>("ReviewComment")({
   id: S.String,
   author: Author,
   body: S.String,
   path: S.String,
-  originalLine: S.NullOr(S.Number),
+  originalLine: S.Number,
   diffHunk: S.String,
-  // createdAt: S.String,
+  createdAt: S.String,
 }) {}
 
-export class NodeComments extends S.Class<NodeComments>("github/NodeComments")({
+export class NodeComments extends S.Class<NodeComments>("NodeComments")({
   nodes: S.Array(ReviewComment),
 }) {}
 
-export class ReviewThreadNode extends S.Class<ReviewThreadNode>(
-  "github/ReviewThreadNode",
+export class ReviewThreadsNode extends S.Class<ReviewThreadsNode>(
+  "ReviewThreadsNode",
 )({
   isCollapsed: S.Boolean,
   isOutdated: S.Boolean,
@@ -67,14 +75,6 @@ export class ReviewThreadNode extends S.Class<ReviewThreadNode>(
   readonly shouldDisplayThread = !this.isCollapsed && !this.isOutdated
 }
 
-export class ReviewThreadsEdge extends S.Class<ReviewThreadsEdge>(
-  "ReviewThreadsEdge",
-)({
-  node: ReviewThreadNode,
-}) {}
-
-export class ReviewThreads extends S.Class<ReviewThreads>(
-  "github/ReviewThreads",
-)({
-  edges: S.Array(ReviewThreadsEdge),
+export class ReviewThreads extends S.Class<ReviewThreads>("ReviewThreads")({
+  nodes: S.Array(ReviewThreadsNode),
 }) {}