lalph 0.3.92 → 0.3.94

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lalph",
   "type": "module",
-  "version": "0.3.92",
+  "version": "0.3.94",
   "publishConfig": {
     "access": "public"
   },
@@ -37,17 +37,17 @@
   "devDependencies": {
     "@changesets/changelog-github": "^0.6.0",
     "@changesets/cli": "^2.30.0",
-    "@effect/ai-openai": "4.0.0-beta.35",
-    "@effect/ai-openai-compat": "4.0.0-beta.35",
-    "@effect/language-service": "^0.80.0",
-    "@effect/platform-node": "4.0.0-beta.35",
+    "@effect/ai-openai": "4.0.0-beta.36",
+    "@effect/ai-openai-compat": "4.0.0-beta.36",
+    "@effect/language-service": "^0.81.0",
+    "@effect/platform-node": "4.0.0-beta.36",
     "@linear/sdk": "^78.0.0",
     "@octokit/plugin-rest-endpoint-methods": "^17.0.0",
     "@octokit/types": "^16.0.0",
-    "@typescript/native-preview": "7.0.0-dev.20260319.1",
-    "clanka": "^0.2.19",
+    "@typescript/native-preview": "7.0.0-dev.20260320.1",
+    "clanka": "^0.2.21",
     "concurrently": "^9.2.1",
-    "effect": "https://pkg.pr.new/Effect-TS/effect-smol/effect@89c3e98",
+    "effect": "4.0.0-beta.36",
     "husky": "^9.1.7",
     "lint-staged": "^16.4.0",
     "octokit": "^5.0.5",

package/src/CurrentIssueSource.ts

@@ -121,6 +121,11 @@ export class CurrentIssueSource extends ServiceMap.Service<
             Effect.retry(refreshSchedule),
             unlessRalph(projectId, Effect.succeed([])),
           ),
+        findById: (projectId, issueId) =>
+          ScopedRef.get(ref).pipe(
+            Effect.flatMap((source) => source.findById(projectId, issueId)),
+            unlessRalph(projectId, Effect.succeed(null)),
+          ),
         createIssue: (projectId, options) =>
           ScopedRef.get(ref).pipe(
             Effect.flatMap((source) => source.createIssue(projectId, options)),

package/src/Github.ts

@@ -492,6 +492,11 @@ export const GithubIssueSource = Layer.effect(
         const settings = yield* Cache.get(projectSettings, projectId)
         return yield* issues(settings)
       }),
+      findById: Effect.fnUntraced(function* (projectId, issueId) {
+        const settings = yield* Cache.get(projectSettings, projectId)
+        const projectIssues = yield* issues(settings)
+        return projectIssues.find((issue) => issue.id === issueId) ?? null
+      }),
       createIssue: Effect.fnUntraced(
         function* (projectId, issue) {
           const { labelFilter, autoMergeLabelName } = yield* Cache.get(

package/src/IssueSource.ts

@@ -14,6 +14,11 @@ export class IssueSource extends ServiceMap.Service<
       projectId: ProjectId,
     ) => Effect.Effect<ReadonlyArray<PrdIssue>, IssueSourceError>
 
+    readonly findById: (
+      projectId: ProjectId,
+      issueId: string,
+    ) => Effect.Effect<PrdIssue | null, IssueSourceError>
+
     readonly createIssue: (
       projectId: ProjectId,
       issue: PrdIssue,

package/src/Linear.ts

@@ -208,45 +208,48 @@ export const LinearIssueSource = Layer.effect(
     const identifierMap = new Map<string, string>()
     const presetMap = new Map<string, CliAgentPreset>()
 
-    const backlogState =
-      state.states.find(
-        (s) => s.type === "backlog" && s.name.toLowerCase().includes("backlog"),
-      ) || state.states.find((s) => s.type === "backlog")!
-    const todoState =
-      state.states.find(
-        (s) =>
-          s.type === "unstarted" &&
-          (s.name.toLowerCase().includes("todo") ||
-            s.name.toLowerCase().includes("unstarted")),
-      ) || state.states.find((s) => s.type === "unstarted")!
-    const inProgressState =
-      state.states.find(
-        (s) =>
-          s.type === "started" &&
-          (s.name.toLowerCase().includes("progress") ||
-            s.name.toLowerCase().includes("started")),
-      ) || state.states.find((s) => s.type === "started")!
-    const inReviewState =
-      state.states.find(
-        (s) => s.type === "started" && s.name.toLowerCase().includes("review"),
-      ) || state.states.find((s) => s.type === "completed")!
-    const doneState = state.states.find((s) => s.type === "completed")!
-
-    const canceledState = state.states.find(
-      (state) => state.type === "canceled",
-    )!
-
-    const linearStateToPrdState = (state: State): PrdIssue["state"] => {
+    const findState = (
+      teamId: string,
+      type: string,
+      names: Array<string> = [],
+      fallbackType = type,
+    ) => {
+      const filtered = state.states.filter((s) => {
+        if (names.length === 0) return s.type === type
+        const name = s.name.toLowerCase()
+        return s.type === type && names.some((n) => name.includes(n))
+      })
+      const withTeamId = filtered.filter((s) => s.teamId === teamId)
+      if (withTeamId.length > 0) return withTeamId[0]!
+      const withoutTeamId = filtered.filter((s) => s.teamId === undefined)
+      if (withoutTeamId.length > 0) return withoutTeamId[0]!
+      return state.states.find((s) => s.type === fallbackType)!
+    }
+
+    const statesForTeamId = memoize((teamId: string) => ({
+      backlog: findState(teamId, "backlog", ["backlog"]),
+      todo: findState(teamId, "unstarted", ["todo", "unstarted"]),
+      inProgress: findState(teamId, "started", ["progress", "started"]),
+      inReview: findState(teamId, "started", ["review"], "completed"),
+      done: findState(teamId, "completed"),
+      canceled: findState(teamId, "canceled"),
+    }))
+
+    const linearStateToPrdState = (
+      state: State,
+      teamId: string,
+    ): PrdIssue["state"] => {
+      const states = statesForTeamId(teamId)
       switch (state.id) {
-        case backlogState.id:
+        case states.backlog.id:
           return "backlog"
-        case todoState.id:
+        case states.todo.id:
           return "todo"
-        case inProgressState.id:
+        case states.inProgress.id:
           return "in-progress"
-        case inReviewState.id:
+        case states.inReview.id:
           return "in-review"
-        case doneState.id:
+        case states.done.id:
           return "done"
         default:
           if (state.type === "backlog") return "backlog"
@@ -256,28 +259,34 @@ export const LinearIssueSource = Layer.effect(
           return "backlog"
       }
     }
-    const prdStateToLinearStateId = (state: PrdIssue["state"]): string => {
+    const prdStateToLinearStateId = (
+      state: PrdIssue["state"],
+      teamId: string,
+    ): string => {
+      const states = statesForTeamId(teamId)
       switch (state) {
         case "backlog":
-          return backlogState.id
+          return states.backlog.id
         case "todo":
-          return todoState.id
+          return states.todo.id
         case "in-progress":
-          return inProgressState.id
+          return states.inProgress.id
         case "in-review":
-          return inReviewState.id
+          return states.inReview.id
         case "done":
-          return doneState.id
+          return states.done.id
       }
     }
 
     const issues = ({
       labelId,
       projectId,
+      teamId,
       autoMergeLabelId,
     }: {
       readonly labelId: Option.Option<string>
       readonly projectId: string
+      readonly teamId: string
       readonly autoMergeLabelId: Option.Option<string>
     }) =>
       linear.issues({ labelId, projectId }).pipe(
@@ -308,7 +317,7 @@ export const LinearIssueSource = Layer.effect(
                   description: issue.description ?? "",
                   priority: issue.priority,
                   estimate: issue.estimate ?? null,
-                  state: linearStateToPrdState(issue.state),
+                  state: linearStateToPrdState(issue.state, teamId),
                   blockedBy: issue.blockedBy.map((r) => r.issue.identifier),
                   autoMerge: autoMergeLabelId.pipe(
                     Option.map((labelId) => issue.labelIds.includes(labelId)),
@@ -325,10 +334,21 @@ export const LinearIssueSource = Layer.effect(
         const settings = yield* Cache.get(projectSettings, projectId)
         return yield* issues({
           projectId: settings.project.id,
+          teamId: settings.teamId,
           labelId: settings.labelId,
           autoMergeLabelId: settings.autoMergeLabelId,
         })
       }),
+      findById: Effect.fnUntraced(function* (projectId, issueId) {
+        const settings = yield* Cache.get(projectSettings, projectId)
+        const projectIssues = yield* issues({
+          projectId: settings.project.id,
+          labelId: settings.labelId,
+          teamId: settings.teamId,
+          autoMergeLabelId: settings.autoMergeLabelId,
+        })
+        return projectIssues.find((issue) => issue.id === issueId) ?? null
+      }),
       createIssue: Effect.fnUntraced(
         function* (projectId, issue) {
           const { teamId, labelId, autoMergeLabelId, project } =
@@ -346,7 +366,7 @@ export const LinearIssueSource = Layer.effect(
               description: issue.description,
               priority: issue.priority,
               estimate: issue.estimate,
-              stateId: prdStateToLinearStateId(issue.state),
+              stateId: prdStateToLinearStateId(issue.state, teamId),
             }),
           )
           const linearIssue = yield* linear.use(() => created.issue!)
@@ -382,7 +402,7 @@ export const LinearIssueSource = Layer.effect(
       ),
       updateIssue: Effect.fnUntraced(
         function* (options) {
-          const { autoMergeLabelId } = yield* Cache.get(
+          const { autoMergeLabelId, teamId } = yield* Cache.get(
             projectSettings,
             options.projectId,
           )
@@ -403,7 +423,7 @@ export const LinearIssueSource = Layer.effect(
             update.description = options.description
           }
           if (options.state) {
-            update.stateId = prdStateToLinearStateId(options.state)
+            update.stateId = prdStateToLinearStateId(options.state, teamId)
           }
           if (
             options.autoMerge !== undefined &&
@@ -466,11 +486,13 @@ export const LinearIssueSource = Layer.effect(
         Effect.mapError((cause) => new IssueSourceError({ cause })),
       ),
       cancelIssue: Effect.fnUntraced(
-        function* (_project, issueId) {
+        function* (projectId, issueId) {
+          const { teamId } = yield* Cache.get(projectSettings, projectId)
+          const states = statesForTeamId(teamId)
           const linearIssueId = identifierMap.get(issueId)!
           yield* linear.use((c) =>
             c.updateIssue(linearIssueId, {
-              stateId: canceledState.id,
+              stateId: states.canceled.id,
             }),
           )
         },
@@ -869,6 +891,7 @@ class LinearState extends Persistable.Class<{
         id: Schema.String,
         name: Schema.String,
         type: Schema.String,
+        teamId: Schema.optional(Schema.String),
       }),
     ),
     viewer: Schema.Struct({
@@ -876,3 +899,14 @@ class LinearState extends Persistable.Class<{
     }),
   }),
 }) {}
+
+const memoize = <A, B>(f: (a: A) => B): ((a: A) => B) => {
+  const cache = new Map<A, B>()
+  return (a: A) => {
+    const cached = cache.get(a)
+    if (cached) return cached
+    const b = f(a)
+    cache.set(a, b)
+    return b
+  }
+}

package/src/TaskTools.ts

@@ -35,20 +35,20 @@ export class CurrentTaskRef extends ServiceMap.Service<
   }
 }
 
-const TaskList = Schema.Array(
-  Schema.Struct({
-    id: Schema.String.annotate({
-      documentation: "The unique identifier of the task.",
-    }),
-    ...Struct.pick(PrdIssue.fields, [
-      "title",
-      "description",
-      "state",
-      "priority",
-      "blockedBy",
-    ]),
+const Task = Schema.Struct({
+  id: Schema.String.annotate({
+    documentation: "The unique identifier of the task.",
   }),
-)
+  ...Struct.pick(PrdIssue.fields, [
+    "title",
+    "description",
+    "state",
+    "priority",
+    "blockedBy",
+  ]),
+})
+
+const TaskList = Schema.Array(Task)
 
 const toTaskListItem = (issue: PrdIssue) => ({
   id: issue.id ?? "",
@@ -77,6 +77,14 @@ export class TaskTools extends Toolkit.make(
     success: Schema.String,
     dependencies: [CurrentProjectId],
   }),
+  Tool.make("findTaskById", {
+    description: "Find a task by it's id. Returns null if not found.",
+    parameters: Schema.String.annotate({
+      identifier: "taskId",
+    }),
+    success: Schema.NullOr(Task),
+    dependencies: [CurrentProjectId],
+  }),
   Tool.make("updateTask", {
     description: "Update a task. Supports partial updates",
     parameters: Schema.Struct({
@@ -159,6 +167,14 @@ export const TaskToolsHandlers = TaskToolsWithChoose.toLayer(
         )
         return taskId.id
       }, Effect.orDie),
+      findTaskById: Effect.fn("TaskTools.findTaskById")(function* (taskId) {
+        yield* Effect.log(`Calling "findTaskById"`).pipe(
+          Effect.annotateLogs({ taskId }),
+        )
+        const projectId = yield* CurrentProjectId
+        const task = yield* source.findById(projectId, taskId)
+        return task ? toTaskListItem(task) : null
+      }, Effect.orDie),
       updateTask: Effect.fn("TaskTools.updateTask")(function* (options) {
         yield* Effect.log(`Calling "updateTask"`).pipe(
           Effect.annotateLogs({ taskId: options.taskId }),