@qotaq/lalphgram 0.1.0

package/src/services/ProjectStore.ts

@@ -0,0 +1,140 @@
+/**
+ * Project store — reads/writes lalph project configuration
+ * @since 1.0.0
+ */
+import { FileSystem, Path } from "@effect/platform"
+import type { Option } from "effect"
+import { Context, Data, Effect, Layer, Schema } from "effect"
+import { LalphProject } from "../schemas/ProjectSchemas.js"
+import { AppContext } from "./AppContext.js"
+
+/**
+ * @since 1.0.0
+ * @category errors
+ */
+export class ProjectStoreError extends Data.TaggedError("ProjectStoreError")<{
+  message: string
+  cause: unknown
+}> {}
+
+/**
+ * @since 1.0.0
+ * @category services
+ */
+export interface ProjectStoreService {
+  readonly listProjects: Effect.Effect<ReadonlyArray<LalphProject>, ProjectStoreError>
+  readonly getProject: (id: string) => Effect.Effect<LalphProject, ProjectStoreError>
+  readonly createProject: (data: {
+    readonly id: string
+    readonly targetBranch: Option.Option<string>
+    readonly concurrency: number
+    readonly gitFlow: "pr" | "commit"
+    readonly reviewAgent: boolean
+  }) => Effect.Effect<LalphProject, ProjectStoreError>
+}
+
+/**
+ * @since 1.0.0
+ * @category context
+ */
+export class ProjectStore extends Context.Tag("ProjectStore")<
+  ProjectStore,
+  ProjectStoreService
+>() {}
+
+const ProjectsArray = Schema.Array(LalphProject)
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const ProjectStoreLive = Layer.effect(
+  ProjectStore,
+  Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem
+    const pathService = yield* Path.Path
+    const appContext = yield* AppContext
+
+    const filePath = pathService.join(appContext.configDir, "settings.projects")
+
+    const readProjects = Effect.gen(function*() {
+      const exists = yield* fs.exists(filePath).pipe(
+        Effect.mapError((err) =>
+          new ProjectStoreError({ message: `Failed to check projects file: ${String(err)}`, cause: err })
+        )
+      )
+      if (!exists) {
+        const empty: ReadonlyArray<typeof LalphProject.Type> = []
+        return empty
+      }
+
+      const content = yield* fs.readFileString(filePath).pipe(
+        Effect.mapError((err) =>
+          new ProjectStoreError({ message: `Failed to read projects file: ${String(err)}`, cause: err })
+        )
+      )
+      const json = yield* Effect.try({
+        try: () => JSON.parse(content),
+        catch: (err) => new ProjectStoreError({ message: `Failed to parse projects JSON: ${String(err)}`, cause: err })
+      })
+      return yield* Schema.decodeUnknown(ProjectsArray)(json).pipe(
+        Effect.mapError((err) =>
+          new ProjectStoreError({ message: `Failed to decode projects: ${String(err)}`, cause: err })
+        )
+      )
+    })
+
+    const listProjects = readProjects.pipe(
+      Effect.map((projects) => projects.filter((p) => p.enabled))
+    )
+
+    const getProject = (id: string) =>
+      readProjects.pipe(
+        Effect.flatMap((projects) => {
+          const project = projects.find((p) => p.id === id)
+          if (project == null) {
+            return Effect.fail(new ProjectStoreError({ message: `Project not found: ${id}`, cause: null }))
+          }
+          return Effect.succeed(project)
+        })
+      )
+
+    const createProject = (data: {
+      readonly id: string
+      readonly targetBranch: Option.Option<string>
+      readonly concurrency: number
+      readonly gitFlow: "pr" | "commit"
+      readonly reviewAgent: boolean
+    }) =>
+      Effect.gen(function*() {
+        const allProjects = yield* readProjects
+        const newProject = new LalphProject({
+          id: data.id,
+          enabled: true,
+          targetBranch: data.targetBranch,
+          concurrency: data.concurrency,
+          gitFlow: data.gitFlow,
+          reviewAgent: data.reviewAgent
+        })
+        const updated = [...allProjects, newProject]
+        const encoded = yield* Schema.encode(ProjectsArray)(updated).pipe(
+          Effect.mapError((err) =>
+            new ProjectStoreError({ message: `Failed to encode projects: ${String(err)}`, cause: err })
+          )
+        )
+        yield* fs.makeDirectory(pathService.dirname(filePath), { recursive: true }).pipe(
+          Effect.mapError((err) =>
+            new ProjectStoreError({ message: `Failed to create config dir: ${String(err)}`, cause: err })
+          )
+        )
+        yield* fs.writeFileString(filePath, JSON.stringify(encoded, null, 2)).pipe(
+          Effect.mapError((err) =>
+            new ProjectStoreError({ message: `Failed to write projects file: ${String(err)}`, cause: err })
+          )
+        )
+        return newProject
+      })
+
+    return ProjectStore.of({ listProjects, getProject, createProject })
+  })
+)

package/src/services/PullRequestTracker.ts

@@ -0,0 +1,253 @@
+/**
+ * GitHub event source polling service
+ * @since 1.0.0
+ */
+import { Array, Context, Data, Duration, Effect, HashMap, HashSet, Layer, Option, Ref, Schedule, Stream } from "effect"
+import { PRCIFailed, PRCommentAdded, PRConflictDetected, PROpened } from "../Events.js"
+import type { PullRequestEvent } from "../Events.js"
+import type { GitHubPullRequest, GitHubRepo } from "../schemas/GitHubSchemas.js"
+import { GitHubRepo as GitHubRepoClass } from "../schemas/GitHubSchemas.js"
+import { AppRuntimeConfig } from "./AppRuntimeConfig.js"
+import { GitHubClient } from "./GitHubClient.js"
+import { LalphConfig } from "./LalphConfig.js"
+
+/**
+ * @since 1.0.0
+ * @category errors
+ */
+export class PullRequestTrackerError extends Data.TaggedError("PullRequestTrackerError")<{
+  message: string
+  cause: unknown
+}> {}
+
+/**
+ * @since 1.0.0
+ * @category services
+ */
+export interface PullRequestTrackerService {
+  readonly eventStream: Stream.Stream<PullRequestEvent, PullRequestTrackerError>
+}
+
+/**
+ * @since 1.0.0
+ * @category context
+ */
+export class PullRequestTracker extends Context.Tag("PullRequestTracker")<
+  PullRequestTracker,
+  PullRequestTrackerService
+>() {}
+
+interface PRWithRepo {
+  readonly pr: GitHubPullRequest
+  readonly repo: GitHubRepo
+}
+
+const makeRepoFromFullName = (fullName: string) =>
+  new GitHubRepoClass({
+    id: 0,
+    name: "",
+    full_name: fullName,
+    owner: { login: "" },
+    html_url: ""
+  })
+
+const isCIFailed = (state: string, checkRuns: ReadonlyArray<{ readonly conclusion: string | null }>) => {
+  const anyCheckFailed = Array.some(
+    checkRuns,
+    (cr) => cr.conclusion !== null && cr.conclusion !== "success" && cr.conclusion !== "skipped"
+  )
+  return state === "failure" || anyCheckFailed
+}
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const PullRequestTrackerLive = Layer.effect(
+  PullRequestTracker,
+  Effect.gen(function*() {
+    const config = yield* AppRuntimeConfig
+    const lalphConfig = yield* LalphConfig
+    const github = yield* GitHubClient
+    const interval = Duration.seconds(config.pollIntervalSeconds)
+
+    const authenticatedUser = yield* github.getAuthenticatedUser().pipe(
+      Effect.mapError((err) =>
+        new PullRequestTrackerError({ message: `Failed to get authenticated user: ${String(err)}`, cause: err })
+      )
+    )
+
+    const knownPRsRef = yield* Ref.make(HashSet.empty<number>())
+    const conflictNotifiedRef = yield* Ref.make(HashSet.empty<number>())
+    const lastCommentIdsRef = yield* Ref.make(HashMap.empty<number, number>())
+    const failureNotifiedRef = yield* Ref.make(HashMap.empty<number, string>())
+    const isFirstCycleRef = yield* Ref.make(true)
+
+    const pollCycle = Effect.gen(function*() {
+      const isFirstCycle = yield* Ref.get(isFirstCycleRef)
+      const knownPRs = yield* Ref.get(knownPRsRef)
+      const conflictNotified = yield* Ref.get(conflictNotifiedRef)
+      const lastCommentIds = yield* Ref.get(lastCommentIdsRef)
+
+      const allRepos = yield* github.listUserRepos().pipe(
+        Effect.mapError((err) =>
+          new PullRequestTrackerError({ message: `Failed to list repos: ${String(err)}`, cause: err })
+        )
+      )
+
+      const repos = allRepos.filter((repo) => repo.full_name === lalphConfig.repoFullName)
+
+      const allPRsWithRepos = yield* Effect.forEach(repos, (repo) =>
+        github.listOpenPRs(repo).pipe(
+          Effect.map(Array.map((pr): PRWithRepo => ({ pr, repo }))),
+          Effect.mapError((err) =>
+            new PullRequestTrackerError({
+              message: `Failed to list PRs for ${repo.full_name}: ${String(err)}`,
+              cause: err
+            })
+          )
+        )).pipe(Effect.map(Array.flatten))
+
+      const events: Array<PullRequestEvent> = []
+      const currentPRIds = HashSet.fromIterable(allPRsWithRepos.map(({ pr }) => pr.id))
+
+      // Detect new PRs (only emit PROpened after first cycle)
+      for (const { pr } of allPRsWithRepos) {
+        if (!HashSet.has(knownPRs, pr.id) && !isFirstCycle) {
+          events.push(new PROpened({ pr }))
+        }
+      }
+
+      // Detect conflicts (emit even on first cycle)
+      for (const { pr } of allPRsWithRepos) {
+        if (pr.hasConflicts && !HashSet.has(conflictNotified, pr.id)) {
+          events.push(new PRConflictDetected({ pr }))
+        }
+      }
+
+      // Detect new comments
+      for (const { pr, repo } of allPRsWithRepos) {
+        const issueComments = yield* github.listComments(repo, pr.number).pipe(
+          Effect.mapError((err) =>
+            new PullRequestTrackerError({
+              message: `Failed to list comments for PR #${pr.number}: ${String(err)}`,
+              cause: err
+            })
+          )
+        )
+        const reviewComments = yield* github.listReviewComments(repo, pr.number).pipe(
+          Effect.mapError((err) =>
+            new PullRequestTrackerError({
+              message: `Failed to list review comments for PR #${pr.number}: ${String(err)}`,
+              cause: err
+            })
+          )
+        )
+        const comments = [...issueComments, ...reviewComments]
+
+        const filteredComments = comments.filter((c) => c.user.login === authenticatedUser.login)
+
+        const lastId = Option.getOrElse(HashMap.get(lastCommentIds, pr.id), () => 0)
+        const newComments = filteredComments.filter((c) => c.id > lastId)
+
+        if (!isFirstCycle) {
+          for (const comment of newComments) {
+            events.push(new PRCommentAdded({ pr, comment }))
+          }
+        }
+
+        if (filteredComments.length > 0) {
+          const maxId = Math.max(...filteredComments.map((c) => c.id))
+          yield* Ref.update(lastCommentIdsRef, (m) => HashMap.set(m, pr.id, maxId))
+        }
+      }
+
+      // Detect CI failures
+      for (const { pr } of allPRsWithRepos) {
+        const repo = makeRepoFromFullName(pr.repo)
+        const ciStatus = yield* github.getCIStatus(repo, pr.headSha).pipe(
+          Effect.mapError((err) =>
+            new PullRequestTrackerError({
+              message: `Failed to get CI status for PR #${pr.number}: ${String(err)}`,
+              cause: err
+            })
+          )
+        )
+
+        if (isCIFailed(ciStatus.state, ciStatus.checkRuns)) {
+          const failureNotified = yield* Ref.get(failureNotifiedRef)
+          const notifiedSha = HashMap.get(failureNotified, pr.number)
+          const alreadyNotified = Option.isSome(notifiedSha) && notifiedSha.value === pr.headSha
+
+          if (!alreadyNotified) {
+            const failedChecks = Array.filter(
+              ciStatus.checkRuns,
+              (cr) => cr.conclusion !== null && cr.conclusion !== "success" && cr.conclusion !== "skipped"
+            )
+
+            const failedCheckNames = Array.map(failedChecks, (cr) => `- ${cr.name}: ${cr.conclusion}`).join("\n")
+            yield* github.postComment(
+              repo,
+              pr.number,
+              `CI checks failed for this PR:\n${failedCheckNames}`
+            ).pipe(
+              Effect.mapError((err) =>
+                new PullRequestTrackerError({
+                  message: `Failed to post CI failure comment for PR #${pr.number}: ${String(err)}`,
+                  cause: err
+                })
+              )
+            )
+
+            yield* Ref.update(failureNotifiedRef, (m) => HashMap.set(m, pr.number, pr.headSha))
+
+            events.push(
+              new PRCIFailed({
+                pr,
+                failedChecks: Array.map(failedChecks, (cr) => ({
+                  name: cr.name,
+                  html_url: cr.html_url,
+                  conclusion: cr.conclusion ?? "unknown"
+                }))
+              })
+            )
+          }
+        }
+      }
+
+      // Update state
+      yield* Ref.set(knownPRsRef, currentPRIds)
+
+      const conflictedIds = HashSet.fromIterable(
+        allPRsWithRepos.filter(({ pr }) => pr.hasConflicts).map(({ pr }) => pr.id)
+      )
+      yield* Ref.set(conflictNotifiedRef, conflictedIds)
+
+      const currentPRNumbers = HashSet.fromIterable(allPRsWithRepos.map(({ pr }) => pr.number))
+      yield* Ref.update(
+        failureNotifiedRef,
+        (m) => HashMap.filter(m, (_, prNumber) => HashSet.has(currentPRNumbers, prNumber))
+      )
+
+      yield* Ref.set(isFirstCycleRef, false)
+
+      return events
+    })
+
+    const emptyBatch: Array<PullRequestEvent> = []
+
+    const safePollCycle = pollCycle.pipe(
+      Effect.tapError((err) => Effect.logError(`PullRequestTracker poll cycle failed: ${err.message}`)),
+      Effect.orElseSucceed(() => emptyBatch)
+    )
+
+    const eventStream = Stream.repeatEffectWithSchedule(
+      safePollCycle,
+      Schedule.spaced(interval)
+    ).pipe(
+      Stream.flatMap((batch) => Stream.fromIterable(batch))
+    )
+
+    return PullRequestTracker.of({ eventStream })
+  })
+)

package/src/services/TaskTracker/GitHubIssueTracker.ts

@@ -0,0 +1,162 @@
+/**
+ * GitHub Issues implementation of TaskTracker
+ * @since 1.0.0
+ */
+import { Array, DateTime, Duration, Effect, HashMap, Layer, Option, Ref, Schedule, Stream } from "effect"
+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 { OctokitClient } from "../OctokitClient.js"
+import { TaskTracker, TaskTrackerError } from "./TaskTracker.js"
+
+const extractRepoFullName = (repositoryUrl: string): string => {
+  const parts = repositoryUrl.split("/repos/")
+  return parts[1] ?? repositoryUrl
+}
+
+const parseIssueId = (issueId: string) => {
+  const slashIdx = issueId.indexOf("/")
+  const hashIdx = issueId.indexOf("#")
+  const owner = issueId.substring(0, slashIdx)
+  const repo = issueId.substring(slashIdx + 1, hashIdx)
+  const issueNumber = issueId.substring(hashIdx + 1)
+  return { owner, repo, issueNumber }
+}
+
+export const GitHubIssueTrackerLive = Layer.effect(
+  TaskTracker,
+  Effect.gen(function*() {
+    const octokit = yield* OctokitClient
+    const config = yield* AppRuntimeConfig
+    const interval = Duration.seconds(config.pollIntervalSeconds)
+
+    const fetchRecentEvents = (since: string) =>
+      Effect.gen(function*() {
+        const issues = yield* octokit.listUserIssues({
+          state: "all",
+          sort: "updated",
+          since
+        }).pipe(
+          Effect.mapError((err) =>
+            new TaskTrackerError({ message: `GitHub API request failed: ${String(err)}`, cause: err })
+          )
+        )
+        return Array.map(issues, (issue) => {
+          const repoFullName = extractRepoFullName(issue.repositoryUrl)
+          const trackerIssue = new TrackerIssue({
+            id: `${repoFullName}#${issue.number}`,
+            title: issue.title,
+            state: issue.state,
+            url: issue.htmlUrl,
+            createdAt: issue.createdAt,
+            updatedAt: issue.updatedAt
+          })
+          const action = issue.createdAt === issue.updatedAt ? "created" : "updated"
+          return new TrackerIssueEvent({ action, issue: trackerIssue })
+        })
+      })
+
+    const lastPollRef = yield* Ref.make(DateTime.unsafeNow())
+    const knownStatesRef = yield* Ref.make(HashMap.empty<string, string>())
+
+    const pollCycle = Effect.gen(function*() {
+      const lastPoll = yield* Ref.get(lastPollRef)
+      const since = DateTime.formatIso(lastPoll)
+      const knownStates = yield* Ref.get(knownStatesRef)
+      yield* Ref.set(lastPollRef, DateTime.unsafeNow())
+
+      const issueEvents = yield* fetchRecentEvents(since)
+
+      const events: Array<TaskTrackerEvent> = []
+      for (const issueEvent of issueEvents) {
+        if (issueEvent.action === "created") {
+          events.push(new TaskCreated({ issue: issueEvent.issue }))
+          yield* Ref.update(knownStatesRef, HashMap.set(issueEvent.issue.id, issueEvent.issue.state))
+        } else {
+          const previousState = HashMap.get(knownStates, issueEvent.issue.id)
+          const stateChanged = Option.isNone(previousState) || previousState.value !== issueEvent.issue.state
+          if (stateChanged) {
+            events.push(
+              new TaskUpdated({
+                issue: issueEvent.issue,
+                previousState: Option.getOrElse(previousState, () => "Unknown")
+              })
+            )
+          }
+          yield* Ref.update(knownStatesRef, HashMap.set(issueEvent.issue.id, issueEvent.issue.state))
+        }
+      }
+      return events
+    })
+
+    const emptyBatch: Array<TaskTrackerEvent> = []
+    const safePollCycle = pollCycle.pipe(
+      Effect.tapError((err) => Effect.logError(`GitHubIssueTracker poll cycle failed: ${err.message}`)),
+      Effect.orElseSucceed(() => emptyBatch)
+    )
+
+    const eventStream: Stream.Stream<TaskTrackerEvent, TaskTrackerError> = Stream.repeatEffectWithSchedule(
+      safePollCycle,
+      Schedule.spaced(interval)
+    ).pipe(
+      Stream.flatMap((batch) => Stream.fromIterable(batch))
+    )
+
+    return TaskTracker.of({
+      eventStream,
+
+      moveToTodo: (issueId) =>
+        Effect.gen(function*() {
+          const { issueNumber, owner, repo } = parseIssueId(issueId)
+          yield* octokit.addIssueLabels({
+            owner,
+            repo,
+            issueNumber: Number(issueNumber),
+            labels: ["todo"]
+          }).pipe(
+            Effect.mapError((err) =>
+              new TaskTrackerError({ message: `GitHub API request failed: ${String(err)}`, cause: err })
+            )
+          )
+        }),
+
+      setPriorityUrgent: (issueId) =>
+        Effect.gen(function*() {
+          const { issueNumber, owner, repo } = parseIssueId(issueId)
+          yield* octokit.addIssueLabels({
+            owner,
+            repo,
+            issueNumber: Number(issueNumber),
+            labels: ["urgent"]
+          }).pipe(
+            Effect.mapError((err) =>
+              new TaskTrackerError({ message: `GitHub API request failed: ${String(err)}`, cause: err })
+            )
+          )
+        }),
+
+      getIssue: (issueId) =>
+        Effect.gen(function*() {
+          const { issueNumber, owner, repo } = parseIssueId(issueId)
+          const issue = yield* octokit.getIssue({
+            owner,
+            repo,
+            issueNumber: Number(issueNumber)
+          }).pipe(
+            Effect.mapError((err) =>
+              new TaskTrackerError({ message: `GitHub API request failed: ${String(err)}`, cause: err })
+            )
+          )
+          return new TrackerIssue({
+            id: `${owner}/${repo}#${issue.number}`,
+            title: issue.title,
+            state: issue.state,
+            url: issue.htmlUrl,
+            createdAt: issue.createdAt,
+            updatedAt: issue.updatedAt
+          })
+        })
+    })
+  })
+)

package/src/services/TaskTracker/LinearTracker.ts

@@ -0,0 +1,141 @@
+/**
+ * Linear SDK implementation of TaskTracker
+ * @since 1.0.0
+ */
+import { DateTime, Duration, Effect, HashMap, Layer, Option, Ref, Schedule, Stream } from "effect"
+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 { LinearSdkClient } from "../LinearSdkClient.js"
+import { TaskTracker, TaskTrackerError } from "./TaskTracker.js"
+
+export const LinearTrackerLive = Layer.effect(
+  TaskTracker,
+  Effect.gen(function*() {
+    const linearClient = yield* LinearSdkClient
+    const config = yield* AppRuntimeConfig
+    const interval = Duration.seconds(config.pollIntervalSeconds)
+    const todoStateIdRef = yield* Ref.make<string | null>(null)
+
+    const resolveTodoStateId = Effect.gen(function*() {
+      const cached = yield* Ref.get(todoStateIdRef)
+      if (cached !== null) return cached
+
+      const states = yield* linearClient.listWorkflowStates().pipe(
+        Effect.mapError((err) =>
+          new TaskTrackerError({ message: `Failed to fetch workflow states: ${err.message}`, cause: err })
+        )
+      )
+      const todoState = states.find((s) => s.name === "Todo")
+      if (!todoState) {
+        return yield* new TaskTrackerError({ message: "No 'Todo' workflow state found", cause: null })
+      }
+      yield* Ref.set(todoStateIdRef, todoState.id)
+      return todoState.id
+    })
+
+    const fetchRecentEvents = (since: string) =>
+      linearClient.listIssues({ since }).pipe(
+        Effect.map((issues) =>
+          issues.map((node) => {
+            const issue = new TrackerIssue({
+              id: node.identifier,
+              title: node.title,
+              state: node.stateName,
+              url: node.url,
+              createdAt: node.createdAt,
+              updatedAt: node.updatedAt
+            })
+            const action = node.createdAt === node.updatedAt ? "created" : "updated"
+            return new TrackerIssueEvent({ action, issue })
+          })
+        ),
+        Effect.mapError((err) =>
+          new TaskTrackerError({ message: `Failed to get recent events: ${err.message}`, cause: err })
+        )
+      )
+
+    const lastPollRef = yield* Ref.make(DateTime.unsafeNow())
+    const knownStatesRef = yield* Ref.make(HashMap.empty<string, string>())
+
+    const pollCycle = Effect.gen(function*() {
+      const lastPoll = yield* Ref.get(lastPollRef)
+      const since = DateTime.formatIso(lastPoll)
+      const knownStates = yield* Ref.get(knownStatesRef)
+      yield* Ref.set(lastPollRef, DateTime.unsafeNow())
+
+      const issueEvents = yield* fetchRecentEvents(since)
+
+      const events: Array<TaskTrackerEvent> = []
+      for (const issueEvent of issueEvents) {
+        if (issueEvent.action === "created") {
+          events.push(new TaskCreated({ issue: issueEvent.issue }))
+          yield* Ref.update(knownStatesRef, HashMap.set(issueEvent.issue.id, issueEvent.issue.state))
+        } else {
+          const previousState = HashMap.get(knownStates, issueEvent.issue.id)
+          const stateChanged = Option.isNone(previousState) || previousState.value !== issueEvent.issue.state
+          if (stateChanged) {
+            events.push(
+              new TaskUpdated({
+                issue: issueEvent.issue,
+                previousState: Option.getOrElse(previousState, () => "Unknown")
+              })
+            )
+          }
+          yield* Ref.update(knownStatesRef, HashMap.set(issueEvent.issue.id, issueEvent.issue.state))
+        }
+      }
+      return events
+    })
+
+    const emptyBatch: Array<TaskTrackerEvent> = []
+    const safePollCycle = pollCycle.pipe(
+      Effect.tapError((err) => Effect.logError(`LinearTracker poll cycle failed: ${err.message}`)),
+      Effect.orElseSucceed(() => emptyBatch)
+    )
+
+    const eventStream: Stream.Stream<TaskTrackerEvent, TaskTrackerError> = Stream.repeatEffectWithSchedule(
+      safePollCycle,
+      Schedule.spaced(interval)
+    ).pipe(
+      Stream.flatMap((batch) => Stream.fromIterable(batch))
+    )
+
+    return TaskTracker.of({
+      eventStream,
+
+      moveToTodo: (issueId) =>
+        Effect.gen(function*() {
+          const stateId = yield* resolveTodoStateId
+          yield* linearClient.updateIssue({ id: issueId, stateId }).pipe(
+            Effect.mapError((err) =>
+              new TaskTrackerError({ message: `Failed to update issue state: ${err.message}`, cause: err })
+            )
+          )
+        }),
+
+      setPriorityUrgent: (issueId) =>
+        linearClient.updateIssuePriority({ id: issueId, priority: 1 }).pipe(
+          Effect.mapError((err) =>
+            new TaskTrackerError({ message: `Failed to set priority urgent: ${err.message}`, cause: err })
+          )
+        ),
+
+      getIssue: (issueId) =>
+        linearClient.getIssue({ id: issueId }).pipe(
+          Effect.map((node) =>
+            new TrackerIssue({
+              id: node.identifier,
+              title: node.title,
+              state: node.stateName,
+              url: node.url,
+              createdAt: node.createdAt,
+              updatedAt: node.updatedAt
+            })
+          ),
+          Effect.mapError((err) => new TaskTrackerError({ message: `Failed to get issue: ${err.message}`, cause: err }))
+        )
+    })
+  })
+)