@qotaq/lalphgram 0.1.6 → 0.1.8

package/src/Main.ts

@@ -74,18 +74,22 @@ const lalphNotifyCommand = CliCommand.make(
             Effect.map((s) => s.trim())
           )
 
-          // Resolve tsx binary for running the TypeScript shim
-          const tsxPath = yield* PlatformCommand.make("which", "tsx").pipe(
-            PlatformCommand.string,
-            Effect.map((s) => s.trim())
-          )
-
-          // Resolve the SDK-based shim entry point relative to this file
-          const shimMainTs = pathService.join(
+          // Resolve the SDK-based shim entry point relative to this file.
+          // In dev mode (tsx), the file is bin.ts; when built, it's bin.js.
+          const shimDir_ = pathService.join(
             pathService.dirname(fileURLToPath(import.meta.url)),
-            "shim",
-            "bin.ts"
+            "shim"
           )
+          const shimJsExists = yield* fs.exists(pathService.join(shimDir_, "bin.js"))
+          const shimMainTs = pathService.join(shimDir_, shimJsExists ? "bin.js" : "bin.ts")
+
+          // Use node for compiled JS, tsx for TypeScript source
+          const tsxPath = shimJsExists
+            ? process.execPath
+            : yield* PlatformCommand.make("which", "tsx").pipe(
+              PlatformCommand.string,
+              Effect.map((s) => s.trim())
+            )
 
           yield* Effect.log("Resolved shim paths").pipe(
             Effect.annotateLogs({ realClaudePath, tsxPath, shimMainTs })

package/src/lib/StreamJsonParser.ts

@@ -74,7 +74,7 @@ export class StreamJsonInput extends Schema.Class<StreamJsonInput>("StreamJsonIn
   parent_tool_use_id: Schema.NullOr(Schema.String)
 }) {}
 
-const decodeJsonMessage = Schema.decodeUnknown(Schema.parseJson(StreamJsonMessage))
+export const decodeJsonMessage = Schema.decodeUnknown(Schema.parseJson(StreamJsonMessage))
 
 /**
  * Splits a string stream into lines and parses each as a StreamJsonMessage,
@@ -89,7 +89,11 @@ export const parseNdjsonMessages = flow(
     decodeJsonMessage(line).pipe(
       Effect.tapError((err) =>
         Effect.logDebug("Non-JSON stdout line, skipping").pipe(
-          Effect.annotateLogs({ line: line.slice(0, 300), error: err.message.slice(0, 100) })
+          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

package/src/services/ChatMachine.ts

@@ -302,6 +302,15 @@ export const chatMachine = Machine.make(
       analysisFollowUpSent: boolean
     ): Effect.Effect<ChatState, never, never> =>
       Effect.gen(function*() {
+        yield* Effect.log("checkAllReady").pipe(
+          Effect.annotateLogs({
+            spec: String(flags.spec),
+            analysis: String(flags.analysis),
+            idle: String(flags.idle),
+            planType,
+            analysisFollowUpSent: String(analysisFollowUpSent)
+          })
+        )
         if (!flags.spec || !flags.analysis || !flags.idle) {
           return ChatState.SessionRunning({
             projectId,
@@ -660,11 +669,10 @@ export const chatMachine = Machine.make(
             case "SpecReady": {
               if (text === APPROVE_BUTTON_LABEL) {
                 yield* Effect.log("User approved task creation")
-                yield* planSession.approve.pipe(
-                  Effect.tapError((err) => Effect.logError(`Plan approve error: ${err.message}`)),
+                yield* planSession.approve
+                yield* notifier.sendMessage({ text: "Spec approved.", replyKeyboard: IDLE_KEYBOARD }).pipe(
                   Effect.orElseSucceed(() => undefined)
                 )
-                yield* notifier.sendMessage({ text: "Spec approved.", replyKeyboard: IDLE_KEYBOARD })
                 return reply(ChatState.Idle())
               }
               if (text === ABORT_BUTTON_LABEL) {

package/src/services/EventLoop.ts

@@ -87,10 +87,12 @@ const autoMergeLayer = AutoMergeLive.pipe(
   Layer.provide(lalphConfigLayer)
 )
 
-const eventSourcesLayer = PullRequestTrackerLive.pipe(
-  Layer.provide(servicesLayer),
-  Layer.provide(lalphConfigLayer)
-)
+const eventSourcesLayer = process.env["MOCK_GITHUB"] === "1"
+  ? Layer.succeed(PullRequestTracker, { eventStream: Stream.never })
+  : PullRequestTrackerLive.pipe(
+    Layer.provide(servicesLayer),
+    Layer.provide(lalphConfigLayer)
+  )
 
 const branchParserLayer = BranchParserLive
 

package/src/services/LalphConfig.ts

@@ -3,7 +3,7 @@
  * @since 1.0.0
  */
 import { Command, FileSystem, Path } from "@effect/platform"
-import { Context, Data, Effect, Layer, Ref, Schema, Stream } from "effect"
+import { Array as Arr, Context, Data, Effect, Layer, Ref, Schema, Stream } from "effect"
 import { LalphGithubToken, LalphLinearToken } from "../schemas/CredentialSchemas.js"
 import { AppContext } from "./AppContext.js"
 
@@ -43,6 +43,7 @@ export interface LalphConfigService {
   readonly issueSource: "linear" | "github"
   readonly specUploader: "gist" | "telegraph"
   readonly repoFullName: string
+  readonly linearProjectIds: ReadonlyArray<string>
 }
 
 /**
@@ -160,6 +161,39 @@ export const LalphConfigLive = Layer.scoped(
       return parseRepoFullName(output.trim())
     })
 
+    const ProjectEntry = Schema.Struct({ id: Schema.String, enabled: Schema.Boolean })
+
+    const linearProjectIds: ReadonlyArray<string> = issueSource === "linear"
+      ? yield* Effect.gen(function*() {
+        const projectsJson = yield* readStringFile("settings.projects").pipe(
+          Effect.map((raw) => JSON.parse(raw)),
+          Effect.flatMap(Schema.decodeUnknown(Schema.Array(ProjectEntry))),
+          Effect.orElseSucceed((): ReadonlyArray<Schema.Schema.Type<typeof ProjectEntry>> => [])
+        )
+        const enabledIds = Arr.filter(projectsJson, (p) => p.enabled).map((p) => p.id)
+        const projectIds = yield* Effect.forEach(enabledIds, (id) => {
+          const filePath = pathService.join(
+            appContext.projectRoot,
+            ".lalph",
+            "projects",
+            encodeURIComponent(id),
+            "linear.selectedProjectId"
+          )
+          return fs.readFileString(filePath).pipe(
+            Effect.flatMap((content) =>
+              Effect.try({
+                try: () => JSON.parse(content),
+                catch: (err) => err
+              })
+            ),
+            Effect.flatMap(Schema.decodeUnknown(Schema.String)),
+            Effect.option
+          )
+        })
+        return Arr.filterMap(projectIds, (opt) => opt)
+      })
+      : []
+
     const githubTokenRef = yield* Ref.make(githubTokenData.token)
     const linearTokenRef = yield* Ref.make(linearAccessToken)
 
@@ -212,7 +246,8 @@ export const LalphConfigLive = Layer.scoped(
       ),
       issueSource,
       specUploader,
-      repoFullName
+      repoFullName,
+      linearProjectIds
     })
   })
 )

package/src/services/LinearSdkClient.ts

@@ -46,6 +46,7 @@ export interface LinearSdkWorkflowState {
 export interface LinearSdkClientService {
   readonly listIssues: (params: {
     readonly since: string
+    readonly projectIds?: ReadonlyArray<string>
   }) => Effect.Effect<ReadonlyArray<LinearSdkIssue>, LinearSdkClientError>
   readonly getIssue: (params: {
     readonly id: string
@@ -99,7 +100,11 @@ export const LinearSdkClientLive = Layer.effect(
           const c = yield* getClient
           return yield* Effect.tryPromise({
             try: async () => {
-              const connection = await c.issues({ filter: { updatedAt: { gte: new Date(params.since) } } })
+              const filter: Record<string, unknown> = { updatedAt: { gte: new Date(params.since) } }
+              if (params.projectIds && params.projectIds.length > 0) {
+                filter.project = { id: { in: params.projectIds } }
+              }
+              const connection = await c.issues({ filter })
               const results: Array<LinearSdkIssue> = []
               for (const node of connection.nodes) {
                 const state = await node.state

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"
 
 /**
@@ -98,10 +98,13 @@ export type PlanEvent =
   | PlanAnalysisReady
   | PlanAwaitingInput
 
+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>
 }
 
 /**
@@ -152,7 +155,7 @@ export class PlanCommandBuilder extends Context.Tag("PlanCommandBuilder")<
 
 const stripAnsi = (text: string): string =>
   // eslint-disable-next-line no-control-regex
-  text.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "")
+  text.replace(/\x1b\[\??[0-9;]*[a-zA-Z]/g, "")
 
 const WriteToolInput = Schema.Struct({ file_path: Schema.String })
 const EditToolInput = Schema.Struct({ file_path: Schema.String })
@@ -242,14 +245,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,6 +271,8 @@ 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 stage2BufferRef = yield* Ref.make<ReadonlyArray<string>>([])
 
         const flushPendingText = Effect.gen(function*() {
           const pending = yield* Ref.get(pendingTextRef)
@@ -278,6 +285,14 @@ export const PlanSessionLive = Layer.scoped(
           }
         })
 
+        const flushStage2Buffer = Effect.gen(function*() {
+          const buf = yield* Ref.get(stage2BufferRef)
+          if (buf.length > 0) {
+            yield* Queue.offer(eventQueue, new PlanTextOutput({ text: buf.join("\n") }))
+            yield* Ref.set(stage2BufferRef, [])
+          }
+        })
+
         const detectFileEvent = (block: typeof ContentBlock.Type) =>
           Effect.gen(function*() {
             const filePathResult = yield* Effect.gen(function*() {
@@ -380,6 +395,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
@@ -398,9 +414,39 @@ export const PlanSessionLive = Layer.scoped(
               Effect.annotateLogs({ chunkLength: String(chunk.length), preview: chunk.slice(0, 200) })
             )
           ),
-          parseNdjsonMessages,
-          Stream.mapEffect(routeMessage),
+          Stream.map(stripAnsi),
+          Stream.map((text) => text.replace(/\r/g, "\n")),
+          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) {
+                yield* Ref.update(stage2BufferRef, (buf) => [...buf, line])
+                const buf = yield* Ref.get(stage2BufferRef)
+                if (line.includes("\u2713") || line.includes("\u2717") || buf.length >= 20) {
+                  yield* flushStage2Buffer
+                }
+              }
+            })
+          ),
           Stream.runDrain,
+          Effect.tap(() => flushStage2Buffer),
           Effect.tap(() => flushPendingText),
           Effect.tap(() => Effect.log("stdout stream completed")),
           Effect.tapError((err) =>
@@ -437,6 +483,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) })
@@ -517,7 +564,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": {