lalph 0.1.113 → 0.2.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lalph",
   "type": "module",
-  "version": "0.1.113",
+  "version": "0.2.0",
   "publishConfig": {
     "access": "public"
   },

package/src/GitFlow.ts

@@ -7,6 +7,7 @@ import { CurrentWorkerState } from "./Workers.ts"
 import { Atom } from "effect/unstable/reactivity"
 import { parseBranch } from "./shared/git.ts"
 import { AtomRegistry } from "effect/unstable/reactivity"
+import { CurrentProjectId } from "./Settings.ts"
 
 // @effect-diagnostics-next-line leakingRequirements:off
 export class GitFlow extends ServiceMap.Service<
@@ -30,7 +31,7 @@ export class GitFlow extends ServiceMap.Service<
     }) => Effect.Effect<
       void,
       IssueSourceError | PlatformError | GitFlowError,
-      Prd | IssueSource
+      Prd | IssueSource | CurrentProjectId
     >
     readonly autoMerge: (options: {
       readonly targetBranch: string | undefined
@@ -39,7 +40,7 @@ export class GitFlow extends ServiceMap.Service<
     }) => Effect.Effect<
       void,
       IssueSourceError | PlatformError | GitFlowError,
-      Prd | IssueSource
+      Prd | IssueSource | CurrentProjectId
     >
   }
 >()("lalph/GitFlow") {}
@@ -115,7 +116,7 @@ export const GitFlowCommit = Layer.effect(
 
     return GitFlow.of({
       requiresGithubPr: false,
-      branch: `lalph/worker-${workerState.iteration}`,
+      branch: `lalph/worker-${workerState.id}`,
 
       setupInstructions: () =>
         `You are already on a new branch for this task. You do not need to checkout any other branches.`,
@@ -161,12 +162,14 @@ After making any changes, commit them to the same branch. Do not git push your c
       }),
       autoMerge: Effect.fnUntraced(function* (options) {
         const prd = yield* Prd
+        const projectId = yield* CurrentProjectId
         const issue = yield* prd.findById(options.issueId)
         if (!issue || issue.state !== "in-review") {
           return
         }
         const source = yield* IssueSource
         yield* source.updateIssue({
+          projectId,
           issueId: options.issueId,
           state: "done",
         })

package/src/Github.ts

@@ -1,6 +1,7 @@
 import type { Api } from "@octokit/plugin-rest-endpoint-methods"
 import type { OctokitResponse } from "@octokit/types"
 import {
+  Cache,
   Data,
   DateTime,
   Effect,
@@ -17,11 +18,12 @@ import {
 import { Octokit } from "octokit"
 import { IssueSource, IssueSourceError } from "./IssueSource.ts"
 import { PrdIssue } from "./domain/PrdIssue.ts"
-import { Setting } from "./Settings.ts"
+import { CurrentProjectId, ProjectSetting, Settings } from "./Settings.ts"
 import { Prompt } from "effect/unstable/cli"
 import { TokenManager } from "./Github/TokenManager.ts"
 import { GithubCli } from "./Github/Cli.ts"
 import { Reactivity } from "effect/unstable/reactivity"
+import type { ProjectId } from "./domain/Project.ts"
 
 export class GithubError extends Data.TaggedError("GithubError")<{
   readonly cause: unknown
@@ -100,8 +102,19 @@ export const GithubIssueSource = Layer.effect(
   Effect.gen(function* () {
     const github = yield* Github
     const cli = yield* GithubCli
-    const labelFilter = yield* getOrSelectLabel
-    const autoMergeLabelName = yield* getOrSelectAutoMergeLabel
+    const projectSettings = yield* Cache.make({
+      lookup: Effect.fnUntraced(
+        function* (_projectId: ProjectId) {
+          const labelFilter = yield* getOrSelectLabel
+          const autoMergeLabelName = yield* getOrSelectAutoMergeLabel
+          return { labelFilter, autoMergeLabelName } as const
+        },
+        Effect.orDie,
+        (effect, projectId) =>
+          Effect.provideService(effect, CurrentProjectId, projectId),
+      ),
+      capacity: Number.POSITIVE_INFINITY,
+    })
 
     const hasLabel = (
       label: ReadonlyArray<
@@ -115,8 +128,8 @@ export const GithubIssueSource = Layer.effect(
       label.some((l) => (typeof l === "string" ? l === name : l.name === name))
 
     const listOpenBlockedBy = (issueId: number) =>
-      github
-        .stream((rest, page) =>
+      pipe(
+        github.stream((rest, page) =>
           rest.issues.listDependenciesBlockedBy({
             owner: cli.owner,
             repo: cli.repo,
@@ -124,38 +137,42 @@ export const GithubIssueSource = Layer.effect(
             per_page: 100,
             page,
           }),
-        )
-        .pipe(Stream.filter((issue) => issue.state === "open"))
+        ),
+        Stream.filter((issue) => issue.state === "open"),
+      )
 
-    const recentlyClosed = github
-      .stream((rest, page) =>
+    const recentlyClosed = pipe(
+      github.stream((rest, page) =>
         rest.issues.listForRepo({
           owner: cli.owner,
           repo: cli.repo,
           state: "closed",
           per_page: 100,
           page,
-          labels: Option.getOrUndefined(labelFilter),
           since: DateTime.nowUnsafe().pipe(
             DateTime.subtract({ days: 3 }),
             DateTime.formatIso,
           ),
         }),
-      )
-      .pipe(Stream.filter((issue) => issue.state_reason !== "not_planned"))
+      ),
+      Stream.filter((issue) => issue.state_reason !== "not_planned"),
+    )
 
-    const issues = github
-      .stream((rest, page) =>
-        rest.issues.listForRepo({
-          owner: cli.owner,
-          repo: cli.repo,
-          state: "open",
-          per_page: 100,
-          page,
-          labels: Option.getOrUndefined(labelFilter),
-        }),
-      )
-      .pipe(
+    const issues = (options: {
+      readonly labelFilter: Option.Option<string>
+      readonly autoMergeLabelName: Option.Option<string>
+    }) =>
+      pipe(
+        github.stream((rest, page) =>
+          rest.issues.listForRepo({
+            owner: cli.owner,
+            repo: cli.repo,
+            state: "open",
+            per_page: 100,
+            page,
+            labels: Option.getOrUndefined(options.labelFilter),
+          }),
+        ),
         Stream.merge(recentlyClosed),
         Stream.filter((issue) => issue.pull_request === undefined),
         Stream.mapEffect(
@@ -179,7 +196,7 @@ export const GithubIssueSource = Layer.effect(
               estimate: null,
               state,
               blockedBy: dependencies.map((dep) => `#${dep.number}`),
-              autoMerge: autoMergeLabelName.pipe(
+              autoMerge: options.autoMergeLabelName.pipe(
                 Option.map((labelName) => hasLabel(issue.labels, labelName)),
                 Option.getOrElse(() => false),
               ),
@@ -237,9 +254,16 @@ export const GithubIssueSource = Layer.effect(
     })
 
     return yield* IssueSource.make({
-      issues,
+      issues: Effect.fnUntraced(function* (projectId) {
+        const settings = yield* Cache.get(projectSettings, projectId)
+        return yield* issues(settings)
+      }),
       createIssue: Effect.fnUntraced(
-        function* (issue: PrdIssue) {
+        function* (projectId, issue) {
+          const { labelFilter, autoMergeLabelName } = yield* Cache.get(
+            projectSettings,
+            projectId,
+          )
           const created = yield* createIssue({
             owner: cli.owner,
             repo: cli.repo,
@@ -282,6 +306,10 @@ export const GithubIssueSource = Layer.effect(
       ),
       updateIssue: Effect.fnUntraced(
         function* (options) {
+          const { labelFilter, autoMergeLabelName } = yield* Cache.get(
+            projectSettings,
+            options.projectId,
+          )
           const issueNumber = Number(options.issueId.slice(1))
           const update: {
             owner: string
@@ -372,7 +400,7 @@ export const GithubIssueSource = Layer.effect(
         Effect.mapError((cause) => new IssueSourceError({ cause })),
       ),
       cancelIssue: Effect.fnUntraced(
-        function* (issueId: string) {
+        function* (_project, issueId) {
           yield* updateIssue({
             owner: cli.owner,
             repo: cli.repo,
@@ -382,8 +410,34 @@ export const GithubIssueSource = Layer.effect(
         },
         Effect.mapError((cause) => new IssueSourceError({ cause })),
       ),
+      reset: Effect.gen(function* () {
+        const projectId = yield* CurrentProjectId
+        yield* Settings.setProject(labelFilter, Option.none())
+        yield* Settings.setProject(autoMergeLabel, Option.none())
+        yield* Cache.invalidate(projectSettings, projectId)
+      }),
+      settings: (projectId) =>
+        Effect.asVoid(Cache.get(projectSettings, projectId)),
+      info: Effect.fnUntraced(function* (projectId) {
+        const { labelFilter, autoMergeLabelName } = yield* Cache.get(
+          projectSettings,
+          projectId,
+        )
+        console.log(
+          `  Label filter: ${Option.match(labelFilter, {
+            onNone: () => "None",
+            onSome: (value) => value,
+          })}`,
+        )
+        console.log(
+          `  Auto-merge label: ${Option.match(autoMergeLabelName, {
+            onNone: () => "Disabled",
+            onSome: (value) => value,
+          })}`,
+        )
+      }),
       ensureInProgress: Effect.fnUntraced(
-        function* (issueId: string) {
+        function* (_project, issueId) {
           const issueNumber = Number(issueId.slice(1))
           yield* pipe(
             github.request((rest) =>
@@ -403,7 +457,14 @@ export const GithubIssueSource = Layer.effect(
       ),
     })
   }),
-).pipe(Layer.provide([Github.layer, GithubCli.layer, Reactivity.layer]))
+).pipe(
+  Layer.provide([
+    Github.layer,
+    GithubCli.layer,
+    Reactivity.layer,
+    Settings.layer,
+  ]),
+)
 
 export class GithubRepoNotFound extends Data.TaggedError("GithubRepoNotFound") {
   readonly message = "GitHub repository not found"
@@ -411,7 +472,7 @@ export class GithubRepoNotFound extends Data.TaggedError("GithubRepoNotFound") {
 
 // == label filter
 
-const labelFilter = new Setting(
+const labelFilter = new ProjectSetting(
   "github.labelFilter",
   Schema.Option(Schema.String),
 )
@@ -423,11 +484,11 @@ const labelSelect = Effect.gen(function* () {
   const labelOption = Option.some(label.trim()).pipe(
     Option.filter(String.isNonEmpty),
   )
-  yield* labelFilter.set(Option.some(labelOption))
+  yield* Settings.setProject(labelFilter, Option.some(labelOption))
   return labelOption
 })
 const getOrSelectLabel = Effect.gen(function* () {
-  const label = yield* labelFilter.get
+  const label = yield* Settings.getProject(labelFilter)
   if (Option.isSome(label)) {
     return label.value
   }
@@ -436,7 +497,7 @@ const getOrSelectLabel = Effect.gen(function* () {
 
 // == auto merge label
 
-const autoMergeLabel = new Setting(
+const autoMergeLabel = new ProjectSetting(
   "github.autoMergeLabel",
   Schema.Option(Schema.String),
 )
@@ -448,21 +509,17 @@ const autoMergeLabelSelect = Effect.gen(function* () {
   const labelOption = Option.some(label.trim()).pipe(
     Option.filter(String.isNonEmpty),
   )
-  yield* autoMergeLabel.set(Option.some(labelOption))
+  yield* Settings.setProject(autoMergeLabel, Option.some(labelOption))
   return labelOption
 })
 const getOrSelectAutoMergeLabel = Effect.gen(function* () {
-  const label = yield* autoMergeLabel.get
+  const label = yield* Settings.getProject(autoMergeLabel)
   if (Option.isSome(label)) {
     return label.value
   }
   return yield* autoMergeLabelSelect
 })
 
-export const resetGithub = labelFilter
-  .set(Option.none())
-  .pipe(Effect.andThen(autoMergeLabel.set(Option.none())))
-
 // == helpers
 
 const maybeNextPage = (page: number, linkHeader?: string) =>

package/src/IssueSource.ts

@@ -1,17 +1,23 @@
 import { Effect, Schema, ServiceMap } from "effect"
 import type { PrdIssue } from "./domain/PrdIssue.ts"
 import { Reactivity } from "effect/unstable/reactivity"
+import type { ProjectId } from "./domain/Project.ts"
+import type { CurrentProjectId, Settings } from "./Settings.ts"
 
 export class IssueSource extends ServiceMap.Service<
   IssueSource,
   {
-    readonly issues: Effect.Effect<ReadonlyArray<PrdIssue>, IssueSourceError>
+    readonly issues: (
+      projectId: ProjectId,
+    ) => Effect.Effect<ReadonlyArray<PrdIssue>, IssueSourceError>
 
     readonly createIssue: (
+      projectId: ProjectId,
       issue: PrdIssue,
     ) => Effect.Effect<{ id: string; url: string }, IssueSourceError>
 
     readonly updateIssue: (options: {
+      readonly projectId: ProjectId
       readonly issueId: string
       readonly title?: string
       readonly description?: string
@@ -21,10 +27,24 @@ export class IssueSource extends ServiceMap.Service<
     }) => Effect.Effect<void, IssueSourceError>
 
     readonly cancelIssue: (
+      projectId: ProjectId,
       issueId: string,
     ) => Effect.Effect<void, IssueSourceError>
 
+    readonly reset: Effect.Effect<
+      void,
+      IssueSourceError,
+      CurrentProjectId | Settings
+    >
+    readonly settings: (
+      projectId: ProjectId,
+    ) => Effect.Effect<void, IssueSourceError>
+    readonly info: (
+      projectId: ProjectId,
+    ) => Effect.Effect<void, IssueSourceError>
+
     readonly ensureInProgress: (
+      projectId: ProjectId,
       issueId: string,
     ) => Effect.Effect<void, IssueSourceError>
   }
@@ -34,12 +54,27 @@ export class IssueSource extends ServiceMap.Service<
       const reactivity = yield* Reactivity.Reactivity
       return IssueSource.of({
         ...impl,
-        createIssue: (issue) =>
-          reactivity.mutation(["issues"], impl.createIssue(issue)),
+        createIssue: (projectId, issue) =>
+          reactivity.mutation(
+            {
+              issues: [projectId],
+            },
+            impl.createIssue(projectId, issue),
+          ),
         updateIssue: (options) =>
-          reactivity.mutation(["issues"], impl.updateIssue(options)),
-        cancelIssue: (issueId) =>
-          reactivity.mutation(["issues"], impl.cancelIssue(issueId)),
+          reactivity.mutation(
+            {
+              issues: [options.projectId],
+            },
+            impl.updateIssue(options),
+          ),
+        cancelIssue: (projectId, issueId) =>
+          reactivity.mutation(
+            {
+              issues: [projectId],
+            },
+            impl.cancelIssue(projectId, issueId),
+          ),
       })
     })
   }

package/src/IssueSources.ts

@@ -1,27 +1,26 @@
 import { Effect, Layer, Option, pipe, Schema, ServiceMap } from "effect"
-import { Setting, Settings } from "./Settings.ts"
-import { LinearIssueSource, resetLinear } from "./Linear.ts"
+import { CurrentProjectId, Setting, Settings } from "./Settings.ts"
+import { LinearIssueSource } from "./Linear.ts"
 import { Prompt } from "effect/unstable/cli"
-import { GithubIssueSource, resetGithub } from "./Github.ts"
+import { GithubIssueSource } from "./Github.ts"
 import { IssueSource } from "./IssueSource.ts"
 import { PlatformServices } from "./shared/platform.ts"
 import { atomRuntime } from "./shared/runtime.ts"
 import { Atom, Reactivity } from "effect/unstable/reactivity"
 import type { PrdIssue } from "./domain/PrdIssue.ts"
+import type { ProjectId } from "./domain/Project.ts"
 
 const issueSources: ReadonlyArray<typeof CurrentIssueSource.Service> = [
   {
     id: "linear",
     name: "Linear",
     layer: LinearIssueSource,
-    reset: resetLinear,
     githubPrInstructions: `The title of the PR should include the task id.`,
   },
   {
     id: "github",
     name: "GitHub Issues",
     layer: GithubIssueSource,
-    reset: resetGithub,
     githubPrInstructions: `At the start of your PR description, include a line that closes the issue: Closes {task id}`,
   },
 ]
@@ -39,24 +38,18 @@ export const selectIssueSource = Effect.gen(function* () {
       value: s,
     })),
   })
-  yield* selectedIssueSource.set(Option.some(source.id))
-  yield* source.reset
+  yield* Settings.set(selectedIssueSource, Option.some(source.id))
   return source
 })
 
 const getOrSelectIssueSource = Effect.gen(function* () {
-  const issueSource = yield* selectedIssueSource.get
+  const issueSource = yield* Settings.get(selectedIssueSource)
   if (Option.isSome(issueSource)) {
     return issueSources.find((s) => s.id === issueSource.value)!
   }
   return yield* selectIssueSource
 })
 
-export const resetCurrentIssueSource = Effect.gen(function* () {
-  const source = yield* getOrSelectIssueSource
-  yield* source.reset
-})
-
 export class CurrentIssueSource extends ServiceMap.Service<
   CurrentIssueSource,
   {
@@ -67,7 +60,6 @@ export class CurrentIssueSource extends ServiceMap.Service<
       Layer.Error<typeof LinearIssueSource | typeof GithubIssueSource>,
       Layer.Services<typeof LinearIssueSource | typeof GithubIssueSource>
     >
-    readonly reset: Effect.Effect<void, never, Settings>
     readonly githubPrInstructions: string
   }
 >()("lalph/CurrentIssueSource") {
@@ -88,32 +80,36 @@ export const issueSourceRuntime = atomRuntime(
   CurrentIssueSource.layer.pipe(Layer.orDie),
 )
 
-export const currentIssuesAtom = pipe(
-  issueSourceRuntime.atom(
-    Effect.fnUntraced(function* (get) {
-      const source = yield* IssueSource
-      const issues = yield* source.issues.pipe(
-        Effect.withSpan("currentIssuesAtom.refresh"),
-      )
-      const handle = setTimeout(() => {
-        get.refreshSelf()
-      }, 30_000)
-      get.addFinalizer(() => clearTimeout(handle))
-      return issues
-    }),
+export const currentIssuesAtom = Atom.family((projectId: ProjectId) =>
+  pipe(
+    issueSourceRuntime.atom(
+      Effect.fnUntraced(function* (get) {
+        const source = yield* IssueSource
+        const issues = yield* source
+          .issues(projectId)
+          .pipe(Effect.withSpan("currentIssuesAtom.refresh"))
+        const handle = setTimeout(() => {
+          get.refreshSelf()
+        }, 30_000)
+        get.addFinalizer(() => clearTimeout(handle))
+        return issues
+      }),
+    ),
+    atomRuntime.withReactivity([`issues:${projectId}`]),
+    Atom.keepAlive,
   ),
-  atomRuntime.withReactivity(["issues"]),
-  Atom.keepAlive,
 )
 
 // Helpers
 
-const getCurrentIssues = Atom.getResult(currentIssuesAtom, {
-  suspendOnWaiting: true,
-})
+const getCurrentIssues = (projectId: ProjectId) =>
+  Atom.getResult(currentIssuesAtom(projectId), {
+    suspendOnWaiting: true,
+  })
 
 export const checkForWork = Effect.gen(function* () {
-  const issues = yield* getCurrentIssues
+  const projectId = yield* CurrentProjectId
+  const issues = yield* getCurrentIssues(projectId)
   const hasIncomplete = issues.some(
     (issue) => issue.state === "todo" && issue.blockedBy.length === 0,
   )
@@ -125,7 +121,8 @@ export const checkForWork = Effect.gen(function* () {
 export const resetInProgress = Effect.gen(function* () {
   const source = yield* IssueSource
   const reactivity = yield* Reactivity.Reactivity
-  const issues = yield* getCurrentIssues
+  const projectId = yield* CurrentProjectId
+  const issues = yield* getCurrentIssues(projectId)
   const inProgress = issues.filter(
     (issue): issue is PrdIssue & { id: string } =>
       issue.state === "in-progress" && issue.id !== null,
@@ -135,6 +132,7 @@ export const resetInProgress = Effect.gen(function* () {
     inProgress,
     (issue) =>
       source.updateIssue({
+        projectId,
         issueId: issue.id,
         state: "todo",
       }),

package/src/Kvs.ts

@@ -1,7 +1,19 @@
-import { Layer } from "effect"
+import { Layer, LayerMap } from "effect"
 import { KeyValueStore } from "effect/unstable/persistence"
 import { PlatformServices } from "./shared/platform.ts"
+import { ProjectId } from "./domain/Project.ts"
 
 export const layerKvs = KeyValueStore.layerFileSystem(".lalph/config").pipe(
   Layer.provide(PlatformServices),
 )
+
+export class ProjectsKvs extends LayerMap.Service<ProjectsKvs>()(
+  "lalph/ProjectsKvs",
+  {
+    lookup: (projectId: ProjectId) =>
+      KeyValueStore.layerFileSystem(
+        `.lalph/projects/${encodeURIComponent(projectId)}`,
+      ).pipe(Layer.orDie),
+    dependencies: [PlatformServices],
+  },
+) {}