lalph 0.3.27 → 0.3.29

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lalph",
   "type": "module",
-  "version": "0.3.27",
+  "version": "0.3.29",
   "publishConfig": {
     "access": "public"
   },
@@ -22,17 +22,18 @@
   "devDependencies": {
     "@changesets/changelog-github": "^0.5.2",
     "@changesets/cli": "^2.29.8",
-    "@effect/language-service": "^0.73.1",
-    "@effect/platform-node": "4.0.0-beta.2",
+    "@effect/language-service": "^0.75.1",
+    "@effect/platform-node": "4.0.0-beta.7",
     "@linear/sdk": "^75.0.0",
     "@octokit/plugin-rest-endpoint-methods": "^17.0.0",
     "@octokit/types": "^16.0.0",
+    "@typescript/native-preview": "7.0.0-dev.20260219.1",
     "concurrently": "^9.2.1",
-    "effect": "4.0.0-beta.2",
+    "effect": "4.0.0-beta.7",
     "husky": "^9.1.7",
     "lint-staged": "^16.2.7",
     "octokit": "^5.0.5",
-    "oxlint": "^1.47.0",
+    "oxlint": "^1.49.0",
     "prettier": "^3.8.1",
     "tsdown": "^0.20.3",
     "typescript": "^5.9.3",
@@ -48,7 +49,7 @@
     ]
   },
   "scripts": {
-    "check": "concurrently \"tsc --noEmit\" \"oxlint -c .oxlintrc.json\" \"pnpm build\"",
+    "check": "concurrently \"pnpm tsgo --noEmit\" \"pnpm oxlint -c .oxlintrc.json\" \"pnpm build\"",
     "build": "tsdown"
   }
 }

package/src/Github/Cli.ts

@@ -45,7 +45,7 @@ export class GithubCli extends ServiceMap.Service<GithubCli>()(
           Effect.map((data) => {
             const comments =
               data.data.repository.pullRequest.comments.nodes.filter(
-                (c) => !c.author.login.startsWith("github"),
+                (c) => !c.isBot,
               )
             const reviews =
               data.data.repository.pullRequest.reviews.nodes.filter(

package/src/Github/TokenManager.ts

@@ -5,6 +5,7 @@ import {
   Option,
   Schedule,
   Schema,
+  Semaphore,
   ServiceMap,
 } from "effect"
 import {
@@ -64,7 +65,7 @@ export class TokenManager extends ServiceMap.Service<TokenManager>()(
         }
         return currentToken.value
       })
-      const get = Effect.makeSemaphoreUnsafe(1).withPermit(getNoLock)
+      const get = Semaphore.makeUnsafe(1).withPermit(getNoLock)
 
       const deviceCode = Effect.gen(function* () {
         const code = yield* HttpClientRequest.post(

package/src/Github.ts

@@ -31,69 +31,87 @@ export class GithubError extends Data.TaggedError("GithubError")<{
   readonly cause: unknown
 }> {}
 
-export class Github extends ServiceMap.Service<Github>()("lalph/Github", {
-  make: Effect.gen(function* () {
-    const tokens = yield* TokenManager
-    const clients = yield* RcMap.make({
-      lookup: (token: string) =>
-        Effect.succeed(new Octokit({ auth: token }).rest),
-      idleTimeToLive: "1 minute",
-    })
-    const getClient = tokens.get.pipe(
-      Effect.flatMap(({ token }) => RcMap.get(clients, token)),
-      Effect.mapError((cause) => new GithubError({ cause })),
-    )
+export type GithubApi = Api["rest"]
+export type GithubResponse<A> = OctokitResponse<A>
+
+export interface GithubService {
+  readonly request: <A>(
+    f: (_: GithubApi) => Promise<A>,
+  ) => Effect.Effect<A, GithubError, never>
+  readonly wrap: <A, Args extends Array<unknown>>(
+    f: (_: GithubApi) => (...args: Args) => Promise<GithubResponse<A>>,
+  ) => (...args: Args) => Effect.Effect<A, GithubError, never>
+  readonly stream: <A>(
+    f: (_: GithubApi, page: number) => Promise<GithubResponse<Array<A>>>,
+  ) => Stream.Stream<A, GithubError, never>
+}
 
-    const request = <A>(f: (_: Api["rest"]) => Promise<A>) =>
-      getClient.pipe(
-        Effect.flatMap((rest) =>
-          Effect.tryPromise({
-            try: () => f(rest),
-            catch: (cause) => new GithubError({ cause }),
-          }),
-        ),
-        Effect.scoped,
-        Effect.withSpan("Github.request"),
+export class Github extends ServiceMap.Service<Github, GithubService>()(
+  "lalph/Github",
+  {
+    make: Effect.gen(function* () {
+      const tokens = yield* TokenManager
+      const clients = yield* RcMap.make({
+        lookup: (token: string) =>
+          Effect.succeed(new Octokit({ auth: token }).rest),
+        idleTimeToLive: "1 minute",
+      })
+      const getClient = tokens.get.pipe(
+        Effect.flatMap(({ token }) => RcMap.get(clients, token)),
+        Effect.mapError((cause) => new GithubError({ cause })),
       )
 
-    const wrap =
-      <A, Args extends Array<unknown>>(
-        f: (_: Api["rest"]) => (...args: Args) => Promise<OctokitResponse<A>>,
-      ) =>
-      (...args: Args) =>
+      const request = <A>(f: (_: GithubApi) => Promise<A>) =>
         getClient.pipe(
           Effect.flatMap((rest) =>
             Effect.tryPromise({
-              try: () => f(rest)(...args),
+              try: () => f(rest),
               catch: (cause) => new GithubError({ cause }),
             }),
           ),
           Effect.scoped,
-          Effect.map((_) => _.data),
-          Effect.withSpan("Github.wrap"),
+          Effect.withSpan("Github.request"),
         )
 
-    const stream = <A>(
-      f: (_: Api["rest"], page: number) => Promise<OctokitResponse<Array<A>>>,
-    ) =>
-      Stream.paginate(0, (page) =>
-        getClient.pipe(
-          Effect.flatMap((rest) =>
-            Effect.tryPromise({
-              try: () => f(rest, page),
-              catch: (cause) => new GithubError({ cause }),
-            }),
-          ),
-          Effect.scoped,
-          Effect.map(
-            (_) => [_.data, maybeNextPage(page, _.headers.link)] as const,
+      const wrap =
+        <A, Args extends Array<unknown>>(
+          f: (_: GithubApi) => (...args: Args) => Promise<OctokitResponse<A>>,
+        ) =>
+        (...args: Args) =>
+          getClient.pipe(
+            Effect.flatMap((rest) =>
+              Effect.tryPromise({
+                try: () => f(rest)(...args),
+                catch: (cause) => new GithubError({ cause }),
+              }),
+            ),
+            Effect.scoped,
+            Effect.map((_) => _.data),
+            Effect.withSpan("Github.wrap"),
+          )
+
+      const stream = <A>(
+        f: (_: GithubApi, page: number) => Promise<OctokitResponse<Array<A>>>,
+      ) =>
+        Stream.paginate(0, (page) =>
+          getClient.pipe(
+            Effect.flatMap((rest) =>
+              Effect.tryPromise({
+                try: () => f(rest, page),
+                catch: (cause) => new GithubError({ cause }),
+              }),
+            ),
+            Effect.scoped,
+            Effect.map(
+              (_) => [_.data, maybeNextPage(page, _.headers.link)] as const,
+            ),
           ),
-        ),
-      )
+        )
 
-    return { request, wrap, stream } as const
-  }),
-}) {
+      return { request, wrap, stream } as const
+    }),
+  },
+) {
   static layer = Layer.effect(this, this.make).pipe(
     Layer.provide(TokenManager.layer),
   )

package/src/Linear/TokenManager.ts

@@ -2,10 +2,12 @@ import {
   DateTime,
   Deferred,
   Effect,
+  Encoding,
   Layer,
   Option,
   Schedule,
   Schema,
+  Semaphore,
   ServiceMap,
 } from "effect"
 import {
@@ -18,7 +20,6 @@ import {
   HttpServerRequest,
   HttpServerResponse,
 } from "effect/unstable/http"
-import { Base64Url } from "effect/encoding"
 import { NodeHttpServer } from "@effect/platform-node"
 import { createServer } from "node:http"
 import { KeyValueStore } from "effect/unstable/persistence"
@@ -80,7 +81,7 @@ export class TokenManager extends ServiceMap.Service<TokenManager>()(
           return currentToken.value
         }),
       )
-      const get = Effect.makeSemaphoreUnsafe(1).withPermit(getNoLock)
+      const get = Semaphore.makeUnsafe(1).withPermit(getNoLock)
 
       const pkce = Effect.gen(function* () {
         const deferred = yield* Deferred.make<typeof CallbackParams.Type>()
@@ -116,7 +117,9 @@ export class TokenManager extends ServiceMap.Service<TokenManager>()(
         const verifierSha256 = yield* Effect.promise(() =>
           crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier)),
         )
-        const challenge = Base64Url.encode(new Uint8Array(verifierSha256))
+        const challenge = Encoding.encodeBase64Url(
+          new Uint8Array(verifierSha256),
+        )
 
         const url = `https://linear.app/oauth/authorize?client_id=${clientId}&redirect_uri=${encodeURIComponent(redirectUri)}&response_type=code&scope=read,write&code_challenge=${challenge}&code_challenge_method=S256`
 

package/src/Prd.ts

@@ -7,6 +7,7 @@ import {
   Path,
   PlatformError,
   Schedule,
+  Semaphore,
   ServiceMap,
   Stream,
 } from "effect"
@@ -65,7 +66,7 @@ export class Prd extends ServiceMap.Service<
       { suspendOnWaiting: true },
     )
 
-    const syncSemaphore = Effect.makeSemaphoreUnsafe(1)
+    const syncSemaphore = Semaphore.makeUnsafe(1)
 
     const maybeRevertIssue = Effect.fnUntraced(function* (options: {
       readonly issueId: string

package/src/Worktree.ts

@@ -264,7 +264,7 @@ const makeExecHelpers = Effect.fnUntraced(function* (options: {
         if (DateTime.isLessThan(deadline, now)) {
           return Effect.fail(new RunnerStalled())
         }
-        const timeUntilDeadline = DateTime.distanceDuration(deadline, now)
+        const timeUntilDeadline = DateTime.distance(deadline, now)
         return Effect.flatMap(Effect.sleep(timeUntilDeadline), loop)
       })
 

package/src/commands/root.ts

@@ -8,6 +8,7 @@ import {
   Iterable,
   Option,
   Path,
+  Semaphore,
   Stream,
 } from "effect"
 import { PromptGen } from "../PromptGen.ts"
@@ -248,7 +249,7 @@ const runProject = Effect.fnUntraced(
   }) {
     const isFinite = Number.isFinite(options.iterations)
     const iterationsDisplay = isFinite ? options.iterations : "unlimited"
-    const semaphore = Effect.makeSemaphoreUnsafe(options.project.concurrency)
+    const semaphore = Semaphore.makeUnsafe(options.project.concurrency)
     const fibers = yield* FiberSet.make()
 
     yield* resetInProgress.pipe(Effect.withSpan("Main.resetInProgress"))

package/src/domain/GithubComment.ts

@@ -4,12 +4,29 @@ export class Author extends S.Class<Author>("Author")({
   login: S.String,
 }) {}
 
+// Prefixes of bot users that we want to ignore when determining if a comment is
+// from a bot or not. This is not an exhaustive list, but covers some common
+// cases.
+const commonBotUserPrefixes = [
+  "dependabot",
+  "github",
+  "changeset",
+  "renovate",
+  "snyk",
+  "coderabbit",
+]
+
 export class Comment extends S.Class<Comment>("Comment")({
   id: S.String,
   body: S.String,
   author: Author,
   createdAt: S.String,
-}) {}
+}) {
+  get isBot() {
+    const login = this.author.login.toLowerCase()
+    return commonBotUserPrefixes.some((prefix) => login.startsWith(prefix))
+  }
+}
 
 export class PullRequestComments extends S.Class<PullRequestComments>(
   "PullRequestComments",