npm - lalph - Versions diffs - 0.0.0 - Mend

lalph 0.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

package/LICENSE +21 -0
package/README.md +28 -0
package/dist/cli.mjs +132396 -0
package/package.json +32 -0
package/src/Kvs.ts +3 -0
package/src/Linear/TokenManager.ts +183 -0
package/src/Linear.ts +149 -0
package/src/Prd.ts +188 -0
package/src/PromptGen.ts +64 -0
package/src/Runner.ts +52 -0
package/src/Settings.ts +70 -0
package/src/cli.ts +69 -0
package/src/domain/CliAgent.ts +43 -0

package/package.json ADDED Viewed

@@ -0,0 +1,32 @@
+{
+  "name": "lalph",
+  "type": "module",
+  "version": "0.0.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "lalph": "./dist/cli.mjs"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "license": "MIT",
+  "author": "Tim Smart <hello@timsmart.co>",
+  "devDependencies": {
+    "@changesets/changelog-github": "^0.5.2",
+    "@changesets/cli": "^2.29.8",
+    "@effect/language-service": "^0.64.1",
+    "@effect/platform-node": "https://pkg.pr.new/Effect-TS/effect-smol/@effect/platform-node@bc26c98",
+    "@linear/sdk": "^69.0.0",
+    "effect": "https://pkg.pr.new/Effect-TS/effect-smol/effect@bc26c98",
+    "prettier": "^3.7.4",
+    "tsdown": "^0.19.0",
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "check": "tsc --noEmit && prettier --check .",
+    "build": "tsdown"
+  }
+}

package/src/Kvs.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import { KeyValueStore } from "effect/unstable/persistence"
+export const layerKvs = KeyValueStore.layerFileSystem(".lalph/config")

package/src/Linear/TokenManager.ts ADDED Viewed

@@ -0,0 +1,183 @@
+import {
+  DateTime,
+  Deferred,
+  Effect,
+  Layer,
+  Option,
+  Schedule,
+  Schema,
+  ServiceMap,
+} from "effect"
+import {
+  FetchHttpClient,
+  HttpClient,
+  HttpClientRequest,
+  HttpClientResponse,
+  HttpRouter,
+  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"
+import { layerKvs } from "../Kvs.ts"
+const clientId = "852ed0906088135c1f591d234a4eaa4b"
+export class TokenManager extends ServiceMap.Service<TokenManager>()(
+  "lalph/Linear/TokenManager",
+  {
+    make: Effect.gen(function* () {
+      const kvs = yield* KeyValueStore.KeyValueStore
+      const tokenStore = KeyValueStore.toSchemaStore(kvs, AccessToken)
+      const httpClient = (yield* HttpClient.HttpClient).pipe(
+        HttpClient.filterStatusOk,
+        HttpClient.retryTransient({
+          schedule: Schedule.spaced(1000),
+        }),
+      )
+      let currentToken = yield* Effect.orDie(tokenStore.get("accessToken"))
+      const set = (token: AccessToken) =>
+        Effect.orDie(tokenStore.set("accessToken", token))
+      const clear = Effect.orDie(tokenStore.remove("accessToken"))
+      const getNoLock: Effect.Effect<AccessToken> = Effect.gen(function* () {
+        if (Option.isNone(currentToken)) {
+          const newToken = yield* pkce
+          yield* set(newToken)
+          return newToken
+        } else if (currentToken.value.isExpired()) {
+          const newToken = yield* refresh(currentToken.value)
+          if (Option.isNone(newToken)) {
+            yield* clear
+            return yield* getNoLock
+          }
+          yield* set(newToken.value)
+          currentToken = newToken
+          return newToken.value
+        }
+        return currentToken.value
+      })
+      const get = Effect.makeSemaphoreUnsafe(1).withPermit(getNoLock)
+      const pkce = Effect.gen(function* () {
+        const deferred = yield* Deferred.make<typeof CallbackParams.Type>()
+        const CallbackRoute = HttpRouter.add(
+          "GET",
+          "/callback",
+          Effect.gen(function* () {
+            const params = yield* callbackParams
+            yield* Deferred.succeed(deferred, params)
+            return yield* HttpServerResponse.html`
+<html>
+  <body style="font-family: sans-serif; text-align: center; margin-top: 50px;">
+    <h1>Lalph login Successful</h1>
+    <p>You can close this window now.</p>
+  </body>
+</html>
+`
+          }),
+        )
+        yield* HttpRouter.serve(CallbackRoute, {
+          disableListenLog: true,
+          disableLogger: true,
+        }).pipe(
+          Layer.provide(NodeHttpServer.layer(createServer, { port: 34338 })),
+          Layer.build,
+        )
+        const redirectUri = `http://localhost:34338/callback`
+        // client
+        const verifier = crypto.randomUUID()
+        const verifierSha256 = yield* Effect.promise(() =>
+          crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier)),
+        )
+        const challenge = Base64Url.encode(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`
+        console.log("Open this URL to login to Linear:", url)
+        const params = yield* Deferred.await(deferred)
+        const res = yield* HttpClientRequest.post(
+          "https://api.linear.app/oauth/token",
+        ).pipe(
+          HttpClientRequest.bodyUrlParams({
+            code: params.code,
+            redirect_uri: redirectUri,
+            client_id: clientId,
+            code_verifier: verifier,
+            grant_type: "authorization_code",
+          }),
+          httpClient.execute,
+          Effect.flatMap(HttpClientResponse.schemaBodyJson(TokenResponse)),
+        )
+        return AccessToken.fromResponse(res)
+      }).pipe(Effect.scoped, Effect.orDie)
+      const refresh = Effect.fnUntraced(function* (token: AccessToken) {
+        const res = yield* HttpClientRequest.post(
+          "https://api.linear.app/oauth/token",
+        ).pipe(
+          HttpClientRequest.bodyUrlParams({
+            refresh_token: token.refreshToken,
+            client_id: clientId,
+            grant_type: "refresh_token",
+          }),
+          httpClient.execute,
+          Effect.flatMap(HttpClientResponse.schemaBodyJson(TokenResponse)),
+        )
+        return AccessToken.fromResponse(res)
+      }, Effect.option)
+      return { get } as const
+    }),
+  },
+) {
+  static layer = Layer.effect(this, this.make).pipe(
+    Layer.provide([layerKvs, FetchHttpClient.layer]),
+  )
+}
+export class AccessToken extends Schema.Class<AccessToken>(
+  "lalph/Linear/AccessToken",
+)({
+  token: Schema.String,
+  expiresAt: Schema.DateTimeUtc,
+  refreshToken: Schema.String,
+}) {
+  static fromResponse(res: typeof TokenResponse.Type): AccessToken {
+    return new AccessToken({
+      token: res.access_token,
+      refreshToken: res.refresh_token,
+      expiresAt: DateTime.nowUnsafe().pipe(
+        DateTime.add({ seconds: res.expires_in }),
+      ),
+    })
+  }
+  isExpired(): boolean {
+    return DateTime.isPastUnsafe(
+      this.expiresAt.pipe(DateTime.subtract({ minutes: 5 })),
+    )
+  }
+}
+const CallbackParams = Schema.Struct({
+  code: Schema.String,
+})
+const callbackParams = HttpServerRequest.schemaSearchParams(CallbackParams)
+const TokenResponse = Schema.Struct({
+  access_token: Schema.String,
+  token_type: Schema.String,
+  expires_in: Schema.Number,
+  refresh_token: Schema.String,
+  scope: Schema.String,
+})

package/src/Linear.ts ADDED Viewed

@@ -0,0 +1,149 @@
+import { Effect, Stream, Layer, Schema, ServiceMap, Option } from "effect"
+import {
+  Connection,
+  IssueLabel,
+  LinearClient,
+  Project,
+  WorkflowState,
+} from "@linear/sdk"
+import { TokenManager } from "./Linear/TokenManager.ts"
+import { KeyValueStore } from "effect/unstable/persistence"
+import { Prompt } from "effect/unstable/cli"
+import { layerKvs } from "./Kvs.ts"
+import { selectedLabelId, selectedTeamId, Settings } from "./Settings.ts"
+export class Linear extends ServiceMap.Service<Linear>()("lalph/Linear", {
+  make: Effect.gen(function* () {
+    const tokens = yield* TokenManager
+    const client = new LinearClient({
+      accessToken: (yield* tokens.get).token,
+    })
+    const use = <A>(f: (client: LinearClient) => Promise<A>) =>
+      Effect.tryPromise({
+        try: () => f(client),
+        catch: (cause) => new LinearError({ cause }),
+      })
+    const stream = <A>(f: (client: LinearClient) => Promise<Connection<A>>) =>
+      Stream.paginate(
+        null as null | Connection<A>,
+        Effect.fnUntraced(function* (prev) {
+          const connection = yield* prev
+            ? Effect.tryPromise({
+                try: () => prev.fetchNext(),
+                catch: (cause) => new LinearError({ cause }),
+              })
+            : use(f)
+          return [
+            connection.nodes,
+            Option.some(connection).pipe(
+              Option.filter((c) => c.pageInfo.hasNextPage),
+            ),
+          ]
+        }),
+      )
+    const projects = stream((client) => client.projects())
+    const labels = stream((client) => client.issueLabels())
+    const states = yield* Stream.runFold(
+      stream((client) => client.workflowStates()),
+      () => new Map<string, WorkflowState>(),
+      (map, state) => map.set(state.id, state),
+    )
+    return { use, stream, projects, labels, states } as const
+  }),
+}) {
+  static layer = Layer.effect(this, this.make).pipe(
+    Layer.provide(TokenManager.layer),
+  )
+}
+export class LinearError extends Schema.ErrorClass("lalph/LinearError")({
+  _tag: Schema.tag("LinearError"),
+  cause: Schema.Defect,
+}) {}
+export class CurrentProject extends ServiceMap.Service<
+  CurrentProject,
+  Project
+>()("lalph/Linear/CurrentProject") {
+  static store = KeyValueStore.KeyValueStore.use((_) =>
+    Effect.succeed(KeyValueStore.prefix(_, "linear.currentProjectId")),
+  )
+  static select = Effect.gen(function* () {
+    const kvs = yield* CurrentProject.store
+    const linear = yield* Linear
+    const projects = yield* Stream.runCollect(linear.projects)
+    const project = yield* Prompt.select({
+      message: "Select a Linear project",
+      choices: projects.map((project) => ({
+        title: project.name,
+        value: project,
+      })),
+    })
+    yield* kvs.set("", project.id)
+    yield* teamSelect(project)
+    yield* labelSelect
+    return project
+  })
+  static get = Effect.gen(function* () {
+    const linear = yield* Linear
+    const kvs = yield* CurrentProject.store
+    const projectId = yield* kvs.get("")
+    return projectId
+      ? yield* linear
+          .use((c) => c.project(projectId))
+          .pipe(Effect.catch(() => CurrentProject.select))
+      : yield* CurrentProject.select
+  })
+  static layer = Layer.effect(this, this.get).pipe(
+    Layer.provide([Linear.layer, layerKvs, Settings.layer]),
+  )
+}
+export const labelSelect = Effect.gen(function* () {
+  const linear = yield* Linear
+  const labels = yield* Stream.runCollect(linear.labels)
+  const label = yield* Prompt.select({
+    message: "Select a label to filter issues by",
+    choices: [
+      {
+        title: "No Label",
+        value: Option.none<IssueLabel>(),
+      },
+    ].concat(
+      labels.map((label) => ({
+        title: label.name,
+        value: Option.some(label),
+      })),
+    ),
+  })
+  yield* selectedLabelId.set(Option.map(label, (l) => l.id))
+  return label
+})
+const teamSelect = Effect.fnUntraced(function* (project: Project) {
+  const linear = yield* Linear
+  const teams = yield* Stream.runCollect(linear.stream(() => project.teams()))
+  const teamId = yield* Prompt.select({
+    message: "Select a team for new issues",
+    choices: teams.map((team) => ({
+      title: team.name,
+      value: team.id,
+    })),
+  })
+  yield* selectedTeamId.set(Option.some(teamId))
+})

package/src/Prd.ts ADDED Viewed

@@ -0,0 +1,188 @@
+import {
+  Data,
+  Effect,
+  FileSystem,
+  Layer,
+  Option,
+  Schema,
+  ServiceMap,
+  Stream,
+  SubscriptionRef,
+} from "effect"
+import { CurrentProject, Linear } from "./Linear.ts"
+import { selectedLabelId, selectedTeamId, Settings } from "./Settings.ts"
+import type { Issue } from "@linear/sdk"
+export class Prd extends ServiceMap.Service<Prd>()("lalph/Prd", {
+  make: Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem
+    const linear = yield* Linear
+    const project = yield* CurrentProject
+    const teamId = Option.getOrThrow(yield* selectedTeamId.get)
+    const labelId = yield* selectedLabelId.get
+    const getIssues = linear
+      .stream(() =>
+        project.issues({
+          filter: {
+            labels: {
+              id: labelId.pipe(
+                Option.map((eq) => ({ eq })),
+                Option.getOrNull,
+              ),
+            },
+            state: {
+              type: { eq: "unstarted" },
+            },
+          },
+        }),
+      )
+      .pipe(Stream.runCollect)
+    const initial = yield* getIssues.pipe(Effect.map(PrdList.fromLinearIssues))
+    if (initial.issues.size === 0) {
+      return yield* new NoMoreWork({})
+    }
+    const current = yield* SubscriptionRef.make(initial)
+    const prdFile = `.lalph/prd.json`
+    yield* fs.writeFileString(prdFile, initial.toJson())
+    const sync = Effect.gen(function* () {
+      const json = yield* fs.readFileString(prdFile)
+      const currentValue = yield* SubscriptionRef.get(current)
+      const updated = PrdList.fromJson(json)
+      for (const issue of updated) {
+        if (issue.id === null) {
+          // create new issue
+          yield* linear.use((c) =>
+            c.createIssue({
+              teamId,
+              projectId: project.id,
+              labelIds: Option.toArray(labelId),
+              title: issue.title,
+              description: issue.description,
+              priority: issue.priority,
+              estimate: issue.estimate,
+              stateId: issue.stateId,
+            }),
+          )
+          continue
+        }
+        const existing = currentValue.issues.get(issue.id)
+        if (!existing || !existing.isChangedComparedTo(issue)) continue
+        // update existing issue
+        yield* linear.use((c) =>
+          c.updateIssue(issue.id!, {
+            description: issue.description,
+            stateId: issue.stateId,
+          }),
+        )
+      }
+    })
+    yield* Effect.addFinalizer(() => Effect.orDie(sync))
+    yield* fs.watch(prdFile).pipe(
+      Stream.buffer({
+        capacity: 1,
+        strategy: "dropping",
+      }),
+      Stream.runForEach(() => Effect.ignore(sync)),
+      Effect.forkScoped,
+    )
+    return { current } as const
+  }),
+}) {
+  static layer = Layer.effect(this, this.make).pipe(
+    Layer.provide([Linear.layer, Settings.layer, CurrentProject.layer]),
+  )
+}
+export class NoMoreWork extends Schema.ErrorClass<NoMoreWork>(
+  "lalph/Prd/NoMoreWork",
+)({
+  _tag: Schema.tag("NoMoreWork"),
+}) {
+  readonly message = "No more work to be done!"
+}
+export class PrdIssue extends Schema.Class<PrdIssue>("PrdIssue")({
+  id: Schema.NullOr(Schema.String).annotate({
+    description:
+      "The unique identifier of the issue. If null, it is considered a new issue.",
+  }),
+  title: Schema.String.annotate({
+    description: "The title of the issue",
+  }),
+  description: Schema.String.annotate({
+    description: "The description of the issue",
+  }),
+  priority: Schema.Finite.annotate({
+    description:
+      "The priority of the issue. 0 = No priority, 1 = Urgent, 2 = High, 3 = Normal, 4 = Low.",
+  }),
+  estimate: Schema.NullOr(Schema.Finite).annotate({
+    description:
+      "The estimate of the issue in points. Null if no estimate is set.",
+  }),
+  stateId: Schema.String.annotate({
+    description: "The state ID of the issue.",
+  }),
+}) {
+  static Array = Schema.Array(this)
+  static ArrayFromJson = Schema.toCodecJson(this.Array)
+  static jsonSchemaDoc = Schema.toJsonSchemaDocument(this)
+  static jsonSchema = {
+    ...this.jsonSchemaDoc.schema,
+    $defs: this.jsonSchemaDoc.definitions,
+  }
+  static fromLinearIssue(issue: Issue): PrdIssue {
+    return new PrdIssue({
+      id: issue.id,
+      title: issue.title,
+      description: issue.description ?? "",
+      priority: issue.priority,
+      estimate: issue.estimate ?? null,
+      stateId: issue.stateId!,
+    })
+  }
+  isChangedComparedTo(issue: PrdIssue): boolean {
+    return (
+      this.description !== issue.description || this.stateId !== issue.stateId
+    )
+  }
+}
+export class PrdList extends Data.Class<{
+  readonly issues: ReadonlyMap<string, PrdIssue>
+}> {
+  static fromLinearIssues(issues: Issue[]): PrdList {
+    const map = new Map<string, PrdIssue>()
+    for (const issue of issues) {
+      const prdIssue = PrdIssue.fromLinearIssue(issue)
+      if (!prdIssue.id) continue
+      map.set(prdIssue.id, prdIssue)
+    }
+    return new PrdList({ issues: map })
+  }
+  static fromJson(json: string): ReadonlyArray<PrdIssue> {
+    const issues = Schema.decodeSync(PrdIssue.ArrayFromJson)(JSON.parse(json))
+    return issues
+  }
+  toJson(): string {
+    const issuesArray = Array.from(this.issues.values())
+    const encoded = Schema.encodeSync(PrdIssue.ArrayFromJson)(issuesArray)
+    return JSON.stringify(encoded, null, 2)
+  }
+}

package/src/PromptGen.ts ADDED Viewed

@@ -0,0 +1,64 @@
+import { Effect, FileSystem, Layer, ServiceMap } from "effect"
+import { Linear } from "./Linear.ts"
+import { PrdIssue } from "./Prd.ts"
+export class PromptGen extends ServiceMap.Service<PromptGen>()(
+  "lalph/PromptGen",
+  {
+    make: Effect.gen(function* () {
+      const linear = yield* Linear
+      const fs = yield* FileSystem.FileSystem
+      yield* Effect.scoped(
+        fs.open("PROGRESS.md", {
+          flag: "a+",
+        }),
+      )
+      const prompt = `# Instructions
+1. Decide which single task to work on next from the prd.json file. This should
+   be the task YOU decide as the most important to work on next, not just the
+   first task in the list.
+   - **Important**: Before starting the chosen task, mark it as "in progress" by
+     updating its \`stateId\` in the prd.json file.
+     This prevents other people or agents from working on the same task simultaneously.
+3. Run any checks / feedback loops, such as type checks, unit tests, or linting.
+4. APPEND your progress to the PROGRESS.md file.
+5. Make a git commit when you have made significant progress or completed the task.
+6. Update the prd.json file to reflect any changes in task states.
+   - Add follow up tasks only if needed.
+   - Append to the \`description\` field with any notes.
+   - When a task is complete, set its \`stateId\` to the id that indicates
+     a review is required, or completion if a review state is unavailable.
+Remember, only work on a single task at a time, that you decide is the most
+important to work on next.
+## prd.json format
+Each item in the prd.json file represents a task for the current project.
+The \`stateId\` field indicates the current state of the task. The possible states
+are:
+${Array.from(linear.states.values(), (state) => `- **${state.name}** (stateId: \`${state.id}\`)`).join("\n")}
+### Adding tasks
+To add a new task, append a new item to the prd.json file with the id set to
+\`null\`.
+### prd.json json schema
+\`\`\`json
+${JSON.stringify(PrdIssue.jsonSchema, null, 2)}
+\`\`\`
+`
+      return { prompt } as const
+    }),
+  },
+) {
+  static layer = Layer.effect(this, this.make).pipe(Layer.provide(Linear.layer))
+}

package/src/Runner.ts ADDED Viewed

@@ -0,0 +1,52 @@
+import { Array, Effect, Option } from "effect"
+import { PromptGen } from "./PromptGen.ts"
+import { Prd } from "./Prd.ts"
+import { ChildProcess } from "effect/unstable/process"
+import { Prompt } from "effect/unstable/cli"
+import { allCliAgents } from "./domain/CliAgent.ts"
+import { selectedCliAgentId } from "./Settings.ts"
+export const run = Effect.gen(function* () {
+  const promptGen = yield* PromptGen
+  const cliAgent = yield* getOrSelectCliAgent
+  const cliCommand = cliAgent.command({
+    prompt: promptGen.prompt,
+    prdFilePath: ".lalph/prd.json",
+    progressFilePath: "PROGRESS.md",
+  })
+  const command = ChildProcess.make(cliCommand[0]!, cliCommand.slice(1), {
+    extendEnv: true,
+    stdout: "inherit",
+    stderr: "inherit",
+    stdin: "inherit",
+  })
+  const agent = yield* command
+  const exitCode = yield* agent.exitCode
+  yield* Effect.log(`Agent exited with code: ${exitCode}`)
+}).pipe(Effect.scoped, Effect.provide([PromptGen.layer, Prd.layer]))
+export const selectCliAgent = Effect.gen(function* () {
+  const agent = yield* Prompt.select({
+    message: "Select the CLI agent to use",
+    choices: allCliAgents.map((agent) => ({
+      title: agent.name,
+      value: agent,
+    })),
+  })
+  yield* selectedCliAgentId.set(Option.some(agent.id))
+  return agent
+})
+const getOrSelectCliAgent = Effect.gen(function* () {
+  const selectedAgent = (yield* selectedCliAgentId.get).pipe(
+    Option.filterMap((id) =>
+      Array.findFirst(allCliAgents, (agent) => agent.id === id),
+    ),
+  )
+  if (Option.isSome(selectedAgent)) {
+    return selectedAgent.value
+  }
+  return yield* selectCliAgent
+})