@qotaq/lalphgram 0.1.7 → 0.1.9

package/src/services/PlanSession.ts

@@ -5,7 +5,7 @@
 import { Command, CommandExecutor, FileSystem, Path } from "@effect/platform"
 import { Context, Data, Effect, Exit, Layer, Option, Queue, Ref, Schema, Scope, Stream } from "effect"
 import type { ContentBlock, StreamJsonMessage } from "../lib/StreamJsonParser.js"
-import { AskUserQuestionInput, parseNdjsonMessages } from "../lib/StreamJsonParser.js"
+import { AskUserQuestionInput, decodeJsonMessage } from "../lib/StreamJsonParser.js"
 import { AppContext } from "./AppContext.js"
 
 /**
@@ -84,6 +84,12 @@ export class PlanAnalysisReady extends Data.TaggedClass("PlanAnalysisReady")<{
  */
 export class PlanAwaitingInput extends Data.TaggedClass("PlanAwaitingInput")<Record<string, never>> {}
 
+/**
+ * @since 1.0.0
+ * @category events
+ */
+export class PlanTaskCreationStarted extends Data.TaggedClass("PlanTaskCreationStarted")<Record<string, never>> {}
+
 /**
  * @since 1.0.0
  * @category events
@@ -97,11 +103,15 @@ export type PlanEvent =
   | PlanSpecUpdated
   | PlanAnalysisReady
   | PlanAwaitingInput
+  | PlanTaskCreationStarted
+
+const StdinEOF: unique symbol = Symbol.for("StdinEOF")
+type StdinItem = Uint8Array | typeof StdinEOF
 
 interface ActiveSession {
   readonly process: CommandExecutor.Process
   readonly scope: Scope.CloseableScope
-  readonly stdinQueue: Queue.Queue<Uint8Array>
+  readonly stdinQueue: Queue.Queue<StdinItem>
 }
 
 /**
@@ -242,14 +252,16 @@ export const PlanSessionLive = Layer.scoped(
           )
         )
 
-        const stdinQueue = yield* Queue.unbounded<Uint8Array>()
+        const stdinQueue = yield* Queue.unbounded<StdinItem>()
         yield* Ref.set(sessionRef, Option.some({ process, scope: processScope, stdinQueue }))
         yield* Effect.log("Plan session process spawned").pipe(
           Effect.annotateLogs({ tempFile })
         )
 
         yield* Stream.fromQueue(stdinQueue).pipe(
+          Stream.takeWhile((item): item is Uint8Array => item !== StdinEOF),
           Stream.run(process.stdin),
+          Effect.tap(() => Effect.log("stdin stream closed")),
           Effect.catchAll((err) => Effect.logError(`stdin write error: ${String(err)}`)),
           Effect.forkDaemon
         )
@@ -266,7 +278,7 @@ export const PlanSessionLive = Layer.scoped(
         const pendingTextRef = yield* Ref.make<Option.Option<{ messageId: string; text: string }>>(
           Option.none()
         )
-
+        const stage2Ref = yield* Ref.make(false)
         const flushPendingText = Effect.gen(function*() {
           const pending = yield* Ref.get(pendingTextRef)
           if (Option.isSome(pending)) {
@@ -380,6 +392,7 @@ export const PlanSessionLive = Layer.scoped(
             if (msg.type === "result") {
               yield* flushPendingText
               yield* Ref.set(idleRef, true)
+              yield* Ref.set(stage2Ref, true)
               yield* Queue.offer(eventQueue, new PlanAwaitingInput({}))
               yield* Effect.log("Planner result received")
               return
@@ -400,8 +413,33 @@ export const PlanSessionLive = Layer.scoped(
           ),
           Stream.map(stripAnsi),
           Stream.map((text) => text.replace(/\r/g, "\n")),
-          parseNdjsonMessages,
-          Stream.mapEffect(routeMessage),
+          Stream.splitLines,
+          Stream.filter((line) => line.trim().length > 0),
+          Stream.mapEffect((line) =>
+            Effect.gen(function*() {
+              const isStage2 = yield* Ref.get(stage2Ref)
+              const parsed = yield* decodeJsonMessage(line).pipe(
+                Effect.tapError((err) => {
+                  if (isStage2) return Effect.void
+                  return Effect.logDebug("Non-JSON stdout line, skipping").pipe(
+                    Effect.annotateLogs({
+                      line: line.slice(0, 300),
+                      lineBytes: Array.from(line.slice(0, 100), (c) => c.charCodeAt(0).toString(16)).join(" "),
+                      error: err.message
+                    })
+                  )
+                }),
+                Effect.option
+              )
+              if (Option.isSome(parsed)) {
+                yield* routeMessage(parsed.value)
+              } else if (isStage2) {
+                if (line.includes("[Session started]")) {
+                  yield* Queue.offer(eventQueue, new PlanTaskCreationStarted({}))
+                }
+              }
+            })
+          ),
           Stream.runDrain,
           Effect.tap(() => flushPendingText),
           Effect.tap(() => Effect.log("stdout stream completed")),
@@ -439,6 +477,7 @@ export const PlanSessionLive = Layer.scoped(
         )
 
         yield* Effect.gen(function*() {
+          yield* Effect.log("Waiting for process exit code...")
           const exitCode = yield* process.exitCode
           yield* Effect.log("Plan session process exited").pipe(
             Effect.annotateLogs({ exitCode: String(exitCode) })
@@ -519,7 +558,13 @@ export const PlanSessionLive = Layer.scoped(
       }
       const encoder = new TextEncoder()
       yield* Ref.set(idleRef, false)
-      yield* Queue.offer(current.value.stdinQueue, encoder.encode(JSON.stringify({ type: "shim_approve" }) + "\n"))
+      const payload = JSON.stringify({ type: "shim_approve" }) + "\n"
+      yield* Effect.log("Sending shim_approve to stdin").pipe(
+        Effect.annotateLogs({ payload: payload.trim() })
+      )
+      yield* Queue.offer(current.value.stdinQueue, encoder.encode(payload))
+      yield* Queue.offer(current.value.stdinQueue, StdinEOF)
+      yield* Effect.log("shim_approve + StdinEOF queued to stdin")
     })
 
     const reject = Effect.gen(function*() {

package/src/services/TaskTracker/GitHubIssueTracker.ts

@@ -7,6 +7,7 @@ import { TaskCreated, TaskUpdated } from "../../Events.js"
 import type { TaskTrackerEvent } from "../../Events.js"
 import { TrackerIssue, TrackerIssueEvent } from "../../schemas/TrackerSchemas.js"
 import { AppRuntimeConfig } from "../AppRuntimeConfig.js"
+import { LalphConfig } from "../LalphConfig.js"
 import { OctokitClient } from "../OctokitClient.js"
 import { TaskTracker, TaskTrackerError } from "./TaskTracker.js"
 
@@ -29,7 +30,9 @@ export const GitHubIssueTrackerLive = Layer.effect(
   Effect.gen(function*() {
     const octokit = yield* OctokitClient
     const config = yield* AppRuntimeConfig
+    const lalphConfig = yield* LalphConfig
     const interval = Duration.seconds(config.pollIntervalSeconds)
+    const repoFullName = lalphConfig.repoFullName
 
     const fetchRecentEvents = (since: string) =>
       Effect.gen(function*() {
@@ -42,10 +45,14 @@ export const GitHubIssueTrackerLive = Layer.effect(
             new TaskTrackerError({ message: `GitHub API request failed: ${String(err)}`, cause: err })
           )
         )
-        return Array.map(issues, (issue) => {
-          const repoFullName = extractRepoFullName(issue.repositoryUrl)
+        const filteredIssues = Array.filter(
+          issues,
+          (issue) => extractRepoFullName(issue.repositoryUrl) === repoFullName
+        )
+        return Array.map(filteredIssues, (issue) => {
+          const issueRepoFullName = extractRepoFullName(issue.repositoryUrl)
           const trackerIssue = new TrackerIssue({
-            id: `${repoFullName}#${issue.number}`,
+            id: `${issueRepoFullName}#${issue.number}`,
             title: issue.title,
             state: issue.state,
             url: issue.htmlUrl,

package/src/services/TaskTracker/LinearTracker.ts

@@ -7,6 +7,7 @@ import { TaskCreated, TaskUpdated } from "../../Events.js"
 import type { TaskTrackerEvent } from "../../Events.js"
 import { TrackerIssue, TrackerIssueEvent } from "../../schemas/TrackerSchemas.js"
 import { AppRuntimeConfig } from "../AppRuntimeConfig.js"
+import { LalphConfig } from "../LalphConfig.js"
 import { LinearSdkClient } from "../LinearSdkClient.js"
 import { TaskTracker, TaskTrackerError } from "./TaskTracker.js"
 
@@ -15,7 +16,9 @@ export const LinearTrackerLive = Layer.effect(
   Effect.gen(function*() {
     const linearClient = yield* LinearSdkClient
     const config = yield* AppRuntimeConfig
+    const lalphConfig = yield* LalphConfig
     const interval = Duration.seconds(config.pollIntervalSeconds)
+    const projectIds = lalphConfig.linearProjectIds
     const todoStateIdRef = yield* Ref.make<string | null>(null)
 
     const resolveTodoStateId = Effect.gen(function*() {
@@ -36,7 +39,7 @@ export const LinearTrackerLive = Layer.effect(
     })
 
     const fetchRecentEvents = (since: string) =>
-      linearClient.listIssues({ since }).pipe(
+      linearClient.listIssues({ since, projectIds }).pipe(
         Effect.map((issues) =>
           issues.map((node) => {
             const issue = new TrackerIssue({

package/src/shim/main.ts

@@ -162,7 +162,10 @@ export const shimProgram = Effect.gen(function*() {
           }
           case "shim_approve": {
             yield* writeDebug("shim_approve intercepted")
-            yield* Queue.offer(followUpQueue, FollowUpStop)
+            // Exit immediately — scope cleanup hangs because the stdin
+            // reader fiber is blocked on a Node.js pipe read that
+            // doesn't respond to Effect's fiber interruption.
+            yield* Effect.sync(() => process.exit(0))
             return
           }
           case "shim_start": {