@qotaq/lalphgram 0.1.0

package/src/services/GitHubClient.ts

@@ -0,0 +1,282 @@
+/**
+ * GitHub REST API client service
+ * @since 1.0.0
+ */
+import { Array, Context, Data, Effect, Layer } from "effect"
+import { GitHubComment, GitHubPullRequest, GitHubRepo } from "../schemas/GitHubSchemas.js"
+import { OctokitClient } from "./OctokitClient.js"
+
+/**
+ * @since 1.0.0
+ * @category errors
+ */
+export class GitHubClientError extends Data.TaggedError("GitHubClientError")<{
+  message: string
+  cause: unknown
+}> {}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface GitHubCheckRun {
+  readonly id: number
+  readonly name: string
+  readonly status: string
+  readonly conclusion: string | null
+  readonly html_url: string
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface GitHubCIStatus {
+  readonly state: string
+  readonly checkRuns: ReadonlyArray<GitHubCheckRun>
+}
+
+/**
+ * @since 1.0.0
+ * @category services
+ */
+export interface GitHubClientService {
+  readonly getAuthenticatedUser: () => Effect.Effect<{ readonly login: string }, GitHubClientError>
+  readonly listUserRepos: () => Effect.Effect<ReadonlyArray<GitHubRepo>, GitHubClientError>
+  readonly listOpenPRs: (repo: GitHubRepo) => Effect.Effect<ReadonlyArray<GitHubPullRequest>, GitHubClientError>
+  readonly getPR: (repo: GitHubRepo, prNumber: number) => Effect.Effect<GitHubPullRequest, GitHubClientError>
+  readonly postComment: (
+    repo: GitHubRepo,
+    prNumber: number,
+    body: string
+  ) => Effect.Effect<void, GitHubClientError>
+  readonly listComments: (
+    repo: GitHubRepo,
+    prNumber: number
+  ) => Effect.Effect<ReadonlyArray<GitHubComment>, GitHubClientError>
+  readonly listReviewComments: (
+    repo: GitHubRepo,
+    prNumber: number
+  ) => Effect.Effect<ReadonlyArray<GitHubComment>, GitHubClientError>
+  readonly getCIStatus: (
+    repo: GitHubRepo,
+    ref: string
+  ) => Effect.Effect<GitHubCIStatus, GitHubClientError>
+  readonly mergePR: (
+    repo: GitHubRepo,
+    prNumber: number
+  ) => Effect.Effect<void, GitHubClientError>
+}
+
+/**
+ * @since 1.0.0
+ * @category context
+ */
+export class GitHubClient extends Context.Tag("GitHubClient")<GitHubClient, GitHubClientService>() {}
+
+const splitFullName = (fullName: string): { owner: string; repo: string } => {
+  const slashIndex = fullName.indexOf("/")
+  return {
+    owner: fullName.substring(0, slashIndex),
+    repo: fullName.substring(slashIndex + 1)
+  }
+}
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const GitHubClientLive = Layer.effect(
+  GitHubClient,
+  Effect.gen(function*() {
+    const octokit = yield* OctokitClient
+
+    const getAuthenticatedUser = () =>
+      octokit.getAuthenticatedUser().pipe(
+        Effect.map((user) => ({ login: user.login })),
+        Effect.mapError((err) =>
+          new GitHubClientError({ message: `Failed to get authenticated user: ${err.message}`, cause: err })
+        )
+      )
+
+    const listUserRepos = () =>
+      octokit.listUserRepos({ perPage: 100, type: "owner" }).pipe(
+        Effect.map((repos) =>
+          Array.map(repos, (r) =>
+            new GitHubRepo({
+              id: r.id,
+              name: r.name,
+              full_name: r.fullName,
+              owner: { login: r.owner.login },
+              html_url: r.htmlUrl
+            }))
+        ),
+        Effect.mapError((err) =>
+          new GitHubClientError({ message: `Failed to list user repos: ${err.message}`, cause: err })
+        )
+      )
+
+    const listOpenPRs = (repo: GitHubRepo) => {
+      const { owner, repo: repoName } = splitFullName(repo.full_name)
+      return octokit.listPulls({ owner, repo: repoName, state: "open", perPage: 100 }).pipe(
+        Effect.flatMap((pulls) =>
+          Effect.forEach(pulls, (raw) =>
+            octokit.getPull({ owner, repo: repoName, pullNumber: raw.number }).pipe(
+              Effect.map((detail) =>
+                new GitHubPullRequest({
+                  id: raw.id,
+                  number: raw.number,
+                  title: raw.title,
+                  state: raw.state,
+                  html_url: raw.htmlUrl,
+                  headRef: raw.head.ref,
+                  headSha: raw.head.sha,
+                  hasConflicts: detail.mergeable === false,
+                  repo: repo.full_name
+                })
+              )
+            ))
+        ),
+        Effect.mapError((err) =>
+          new GitHubClientError({
+            message: `Failed to list open PRs for ${repo.full_name}: ${err.message}`,
+            cause: err
+          })
+        )
+      )
+    }
+
+    const getPR = (repo: GitHubRepo, prNumber: number) => {
+      const { owner, repo: repoName } = splitFullName(repo.full_name)
+      return octokit.getPull({ owner, repo: repoName, pullNumber: prNumber }).pipe(
+        Effect.map((raw) =>
+          new GitHubPullRequest({
+            id: raw.id,
+            number: raw.number,
+            title: raw.title,
+            state: raw.state,
+            html_url: raw.htmlUrl,
+            headRef: raw.head.ref,
+            headSha: raw.head.sha,
+            hasConflicts: raw.mergeable === false,
+            repo: repo.full_name
+          })
+        ),
+        Effect.mapError((err) =>
+          new GitHubClientError({
+            message: `Failed to get PR #${prNumber} for ${repo.full_name}: ${err.message}`,
+            cause: err
+          })
+        )
+      )
+    }
+
+    const postComment = (repo: GitHubRepo, prNumber: number, body: string) => {
+      const { owner, repo: repoName } = splitFullName(repo.full_name)
+      return octokit.createIssueComment({ owner, repo: repoName, issueNumber: prNumber, body }).pipe(
+        Effect.mapError((err) =>
+          new GitHubClientError({
+            message: `Failed to post comment on PR #${prNumber} for ${repo.full_name}: ${err.message}`,
+            cause: err
+          })
+        )
+      )
+    }
+
+    const listComments = (repo: GitHubRepo, prNumber: number) => {
+      const { owner, repo: repoName } = splitFullName(repo.full_name)
+      return octokit.listIssueComments({ owner, repo: repoName, issueNumber: prNumber, perPage: 100 }).pipe(
+        Effect.map((comments) =>
+          Array.map(comments, (raw) =>
+            new GitHubComment({
+              id: raw.id,
+              body: raw.body ?? "",
+              user: { login: raw.user?.login ?? "" },
+              created_at: raw.createdAt,
+              html_url: raw.htmlUrl,
+              repo: repo.full_name
+            }))
+        ),
+        Effect.mapError((err) =>
+          new GitHubClientError({
+            message: `Failed to list comments on PR #${prNumber} for ${repo.full_name}: ${err.message}`,
+            cause: err
+          })
+        )
+      )
+    }
+
+    const listReviewComments = (repo: GitHubRepo, prNumber: number) => {
+      const { owner, repo: repoName } = splitFullName(repo.full_name)
+      return octokit.listPullReviewComments({ owner, repo: repoName, pullNumber: prNumber, perPage: 100 }).pipe(
+        Effect.map((comments) =>
+          Array.map(comments, (raw) =>
+            new GitHubComment({
+              id: raw.id,
+              body: raw.body ?? "",
+              user: { login: raw.user?.login ?? "" },
+              created_at: raw.createdAt,
+              html_url: raw.htmlUrl,
+              repo: repo.full_name
+            }))
+        ),
+        Effect.mapError((err) =>
+          new GitHubClientError({
+            message: `Failed to list review comments on PR #${prNumber} for ${repo.full_name}: ${err.message}`,
+            cause: err
+          })
+        )
+      )
+    }
+
+    const getCIStatus = (repo: GitHubRepo, ref: string) => {
+      const { owner, repo: repoName } = splitFullName(repo.full_name)
+      return Effect.all({
+        combinedStatus: octokit.getCombinedStatusForRef({ owner, repo: repoName, ref }),
+        checkRuns: octokit.listCheckRunsForRef({ owner, repo: repoName, ref })
+      }).pipe(
+        Effect.map(({ checkRuns, combinedStatus }) => ({
+          state: combinedStatus.state,
+          checkRuns: Array.map(checkRuns, (cr) => ({
+            id: cr.id,
+            name: cr.name,
+            status: cr.status,
+            conclusion: cr.conclusion,
+            html_url: cr.htmlUrl
+          }))
+        })),
+        Effect.mapError((err) =>
+          new GitHubClientError({
+            message: `Failed to get CI status for ${repo.full_name} ref ${ref}: ${err.message}`,
+            cause: err
+          })
+        )
+      )
+    }
+
+    const mergePR = (repo: GitHubRepo, prNumber: number) => {
+      const { owner, repo: repoName } = splitFullName(repo.full_name)
+      return octokit.mergePull({ owner, repo: repoName, pullNumber: prNumber }).pipe(
+        Effect.asVoid,
+        Effect.mapError((err) =>
+          new GitHubClientError({
+            message: `Failed to merge PR #${prNumber} for ${repo.full_name}: ${err.message}`,
+            cause: err
+          })
+        )
+      )
+    }
+
+    return GitHubClient.of({
+      getAuthenticatedUser,
+      listUserRepos,
+      listOpenPRs,
+      getPR,
+      postComment,
+      listComments,
+      listReviewComments,
+      getCIStatus,
+      mergePR
+    })
+  })
+)

package/src/services/LalphConfig.ts

@@ -0,0 +1,218 @@
+/**
+ * Provides current GitHub and Linear tokens, refreshing from .lalph/config/ file changes
+ * @since 1.0.0
+ */
+import { Command, FileSystem, Path } from "@effect/platform"
+import { Context, Data, Effect, Layer, Ref, Schema, Stream } from "effect"
+import { LalphGithubToken, LalphLinearToken } from "../schemas/CredentialSchemas.js"
+import { AppContext } from "./AppContext.js"
+
+/**
+ * Parse owner/repo from SSH or HTTPS git URL
+ */
+const parseRepoFullName = (url: string): string => {
+  // SSH: git@github.com:owner/repo.git
+  const sshMatch = url.match(/git@[^:]+:([^/]+\/[^/]+?)(?:\.git)?$/)
+  if (sshMatch?.[1] !== undefined) {
+    return sshMatch[1]
+  }
+  // HTTPS: https://github.com/owner/repo.git
+  const httpsMatch = url.match(/https?:\/\/[^/]+\/([^/]+\/[^/]+?)(?:\.git)?$/)
+  if (httpsMatch?.[1] !== undefined) {
+    return httpsMatch[1]
+  }
+  return url
+}
+
+/**
+ * @since 1.0.0
+ * @category errors
+ */
+export class LalphConfigError extends Data.TaggedError("LalphConfigError")<{
+  message: string
+  cause: unknown
+}> {}
+
+/**
+ * @since 1.0.0
+ * @category services
+ */
+export interface LalphConfigService {
+  readonly githubToken: Effect.Effect<string, LalphConfigError>
+  readonly linearToken: Effect.Effect<string, LalphConfigError>
+  readonly issueSource: "linear" | "github"
+  readonly specUploader: "gist" | "telegraph"
+  readonly repoFullName: string
+}
+
+/**
+ * @since 1.0.0
+ * @category context
+ */
+export class LalphConfig extends Context.Tag("lalph-notifier/services/LalphConfig")<
+  LalphConfig,
+  LalphConfigService
+>() {}
+
+const githubTokenFileName = encodeURIComponent("github.accessToken")
+const linearTokenFileName = encodeURIComponent("linear.accessToken")
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const LalphConfigLive = Layer.scoped(
+  LalphConfig,
+  Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem
+    const pathService = yield* Path.Path
+    const appContext = yield* AppContext
+
+    const configDir = appContext.configDir
+
+    const readFile = <A extends { token: string }, I>(key: string, schema: Schema.Schema<A, I>) =>
+      Effect.gen(function*() {
+        const filePath = pathService.join(configDir, encodeURIComponent(key))
+        const content = yield* fs.readFileString(filePath).pipe(
+          Effect.mapError((err) =>
+            new LalphConfigError({
+              message: `Failed to read config file: ${key}`,
+              cause: err
+            })
+          )
+        )
+        const json = yield* Effect.try({
+          try: () => JSON.parse(content),
+          catch: (err) =>
+            new LalphConfigError({
+              message: `Failed to parse JSON in config file: ${key}`,
+              cause: err
+            })
+        })
+        return yield* Schema.decodeUnknown(schema)(json).pipe(
+          Effect.mapError((err) =>
+            new LalphConfigError({
+              message: `Failed to decode config file: ${key}`,
+              cause: err
+            })
+          )
+        )
+      })
+
+    const readStringFile = (key: string) =>
+      Effect.gen(function*() {
+        const filePath = pathService.join(configDir, encodeURIComponent(key))
+        const content = yield* fs.readFileString(filePath).pipe(
+          Effect.mapError((err) =>
+            new LalphConfigError({
+              message: `Failed to read config file: ${key}`,
+              cause: err
+            })
+          )
+        )
+        return yield* Effect.try({
+          try: () => JSON.parse(content),
+          catch: (err) =>
+            new LalphConfigError({
+              message: `Failed to parse JSON in config file: ${key}`,
+              cause: err
+            })
+        })
+      }).pipe(
+        Effect.flatMap(Schema.decodeUnknown(Schema.String)),
+        Effect.mapError((err) =>
+          new LalphConfigError({
+            message: `Failed to decode config file: ${key}`,
+            cause: err
+          })
+        )
+      )
+
+    const githubTokenData = yield* readFile("github.accessToken", LalphGithubToken)
+    const issueSourceRaw = yield* readStringFile("settings.issueSource")
+    const issueSource = issueSourceRaw === "linear" ? "linear" as const : "github" as const
+
+    const specUploaderRaw = yield* readStringFile("settings.specUploader").pipe(
+      Effect.orElseSucceed(() => "telegraph")
+    )
+    const specUploader = specUploaderRaw === "gist"
+      ? "gist" as const
+      : "telegraph" as const
+
+    const linearAccessToken = issueSource === "linear"
+      ? yield* readFile("linear.accessToken", LalphLinearToken).pipe(
+        Effect.map((t) => t.token)
+      )
+      : ""
+
+    const repoFullName = yield* Effect.gen(function*() {
+      const cmd = Command.make("git", "remote", "get-url", "origin").pipe(
+        Command.workingDirectory(appContext.projectRoot)
+      )
+      const output = yield* Command.string(cmd).pipe(
+        Effect.mapError((err) =>
+          new LalphConfigError({
+            message: "Failed to detect git remote origin URL",
+            cause: err
+          })
+        )
+      )
+      return parseRepoFullName(output.trim())
+    })
+
+    const githubTokenRef = yield* Ref.make(githubTokenData.token)
+    const linearTokenRef = yield* Ref.make(linearAccessToken)
+
+    const readAndDecodeToken = <A extends { token: string }, I>(
+      fileName: string,
+      schema: Schema.Schema<A, I>
+    ) =>
+      Effect.gen(function*() {
+        const filePath = pathService.join(configDir, fileName)
+        const content = yield* fs.readFileString(filePath)
+        const json = yield* Effect.try({
+          try: () => JSON.parse(content),
+          catch: (err) => err
+        })
+        return yield* Schema.decodeUnknown(schema)(json)
+      })
+
+    yield* fs.watch(configDir).pipe(
+      Stream.filter((event) => event._tag === "Update"),
+      Stream.mapEffect((event) => {
+        const fileName = pathService.basename(event.path)
+        if (fileName === githubTokenFileName) {
+          return readAndDecodeToken(githubTokenFileName, LalphGithubToken).pipe(
+            Effect.flatMap((decoded) => Ref.set(githubTokenRef, decoded.token)),
+            Effect.tapError((err) => Effect.logWarning(`Failed to refresh GitHub token from file: ${String(err)}`)),
+            Effect.orElseSucceed(() => undefined)
+          )
+        }
+        if (fileName === linearTokenFileName) {
+          return readAndDecodeToken(linearTokenFileName, LalphLinearToken).pipe(
+            Effect.flatMap((decoded) => Ref.set(linearTokenRef, decoded.token)),
+            Effect.tapError((err) => Effect.logWarning(`Failed to refresh Linear token from file: ${String(err)}`)),
+            Effect.orElseSucceed(() => undefined)
+          )
+        }
+        return Effect.void
+      }),
+      Stream.runDrain,
+      Effect.annotateLogs("service", "LalphConfig"),
+      Effect.catchAll((err) => Effect.logError(`Credential watcher stream ended: ${String(err)}`)),
+      Effect.forkScoped
+    )
+
+    return LalphConfig.of({
+      githubToken: Ref.get(githubTokenRef).pipe(
+        Effect.mapError((cause) => new LalphConfigError({ message: "Failed to get GitHub token", cause }))
+      ),
+      linearToken: Ref.get(linearTokenRef).pipe(
+        Effect.mapError((cause) => new LalphConfigError({ message: "Failed to get Linear token", cause }))
+      ),
+      issueSource,
+      specUploader,
+      repoFullName
+    })
+  })
+)

package/src/services/LinearSdkClient.ts

@@ -0,0 +1,181 @@
+/**
+ * Linear SDK client service
+ * @since 1.0.0
+ */
+import { LinearClient } from "@linear/sdk"
+import { Context, Data, Effect, Layer } from "effect"
+import { LalphConfig } from "./LalphConfig.js"
+
+/**
+ * @since 1.0.0
+ * @category errors
+ */
+export class LinearSdkClientError extends Data.TaggedError("LinearSdkClientError")<{
+  message: string
+  cause: unknown
+}> {}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface LinearSdkIssue {
+  readonly id: string
+  readonly identifier: string
+  readonly title: string
+  readonly url: string
+  readonly createdAt: string
+  readonly updatedAt: string
+  readonly stateName: string
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface LinearSdkWorkflowState {
+  readonly id: string
+  readonly name: string
+  readonly type: string
+}
+
+/**
+ * @since 1.0.0
+ * @category services
+ */
+export interface LinearSdkClientService {
+  readonly listIssues: (params: {
+    readonly since: string
+  }) => Effect.Effect<ReadonlyArray<LinearSdkIssue>, LinearSdkClientError>
+  readonly getIssue: (params: {
+    readonly id: string
+  }) => Effect.Effect<LinearSdkIssue, LinearSdkClientError>
+  readonly listWorkflowStates: () => Effect.Effect<ReadonlyArray<LinearSdkWorkflowState>, LinearSdkClientError>
+  readonly updateIssue: (params: {
+    readonly id: string
+    readonly stateId: string
+  }) => Effect.Effect<void, LinearSdkClientError>
+  readonly updateIssuePriority: (params: {
+    readonly id: string
+    readonly priority: number
+  }) => Effect.Effect<void, LinearSdkClientError>
+}
+
+/**
+ * @since 1.0.0
+ * @category context
+ */
+export class LinearSdkClient extends Context.Tag("LinearSdkClient")<LinearSdkClient, LinearSdkClientService>() {}
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const LinearSdkClientLive = Layer.effect(
+  LinearSdkClient,
+  Effect.gen(function*() {
+    const watcher = yield* LalphConfig
+    const initialToken = yield* watcher.linearToken.pipe(
+      Effect.mapError((err) => new LinearSdkClientError({ message: err.message, cause: err }))
+    )
+
+    let currentToken = initialToken
+    let client = new LinearClient({ accessToken: currentToken })
+
+    const getClient = Effect.gen(function*() {
+      const latestToken = yield* watcher.linearToken.pipe(
+        Effect.mapError((err) => new LinearSdkClientError({ message: err.message, cause: err }))
+      )
+      if (latestToken !== currentToken) {
+        currentToken = latestToken
+        client = new LinearClient({ accessToken: latestToken })
+      }
+      return client
+    })
+
+    return LinearSdkClient.of({
+      listIssues: (params) =>
+        Effect.gen(function*() {
+          const c = yield* getClient
+          return yield* Effect.tryPromise({
+            try: async () => {
+              const connection = await c.issues({ filter: { updatedAt: { gte: new Date(params.since) } } })
+              const results: Array<LinearSdkIssue> = []
+              for (const node of connection.nodes) {
+                const state = await node.state
+                results.push({
+                  id: node.id,
+                  identifier: node.identifier,
+                  title: node.title,
+                  url: node.url,
+                  createdAt: node.createdAt.toISOString(),
+                  updatedAt: node.updatedAt.toISOString(),
+                  stateName: state?.name ?? "Unknown"
+                })
+              }
+              return results
+            },
+            catch: (err) => new LinearSdkClientError({ message: `Failed to list issues: ${String(err)}`, cause: err })
+          })
+        }),
+
+      getIssue: (params) =>
+        Effect.gen(function*() {
+          const c = yield* getClient
+          return yield* Effect.tryPromise({
+            try: async () => {
+              const node = await c.issue(params.id)
+              const state = await node.state
+              return {
+                id: node.id,
+                identifier: node.identifier,
+                title: node.title,
+                url: node.url,
+                createdAt: node.createdAt.toISOString(),
+                updatedAt: node.updatedAt.toISOString(),
+                stateName: state?.name ?? "Unknown"
+              }
+            },
+            catch: (err) => new LinearSdkClientError({ message: `Failed to get issue: ${String(err)}`, cause: err })
+          })
+        }),
+
+      listWorkflowStates: () =>
+        Effect.gen(function*() {
+          const c = yield* getClient
+          return yield* Effect.tryPromise({
+            try: () => c.workflowStates(),
+            catch: (err) =>
+              new LinearSdkClientError({ message: `Failed to list workflow states: ${String(err)}`, cause: err })
+          }).pipe(
+            Effect.map((connection) =>
+              connection.nodes.map((node): LinearSdkWorkflowState => ({
+                id: node.id,
+                name: node.name,
+                type: node.type
+              }))
+            )
+          )
+        }),
+
+      updateIssue: (params) =>
+        Effect.gen(function*() {
+          const c = yield* getClient
+          return yield* Effect.tryPromise({
+            try: () => c.updateIssue(params.id, { stateId: params.stateId }),
+            catch: (err) => new LinearSdkClientError({ message: `Failed to update issue: ${String(err)}`, cause: err })
+          }).pipe(Effect.asVoid)
+        }),
+
+      updateIssuePriority: (params) =>
+        Effect.gen(function*() {
+          const c = yield* getClient
+          return yield* Effect.tryPromise({
+            try: () => c.updateIssue(params.id, { priority: params.priority }),
+            catch: (err) =>
+              new LinearSdkClientError({ message: `Failed to update issue priority: ${String(err)}`, cause: err })
+          }).pipe(Effect.asVoid)
+        })
+    })
+  })
+)