lalph 0.0.0

package/src/Settings.ts

@@ -0,0 +1,70 @@
+import { Cache, Effect, Layer, Option, Schema, ServiceMap } from "effect"
+import { KeyValueStore } from "effect/unstable/persistence"
+import { layerKvs } from "./Kvs.ts"
+import { allCliAgents } from "./domain/CliAgent.ts"
+
+export class Settings extends ServiceMap.Service<Settings>()("lalph/Settings", {
+  make: Effect.gen(function* () {
+    const store = KeyValueStore.prefix(
+      yield* KeyValueStore.KeyValueStore,
+      "settings.",
+    )
+
+    const cache = yield* Cache.make({
+      lookup(setting: Setting<string, Schema.Codec<any, any>>) {
+        const s = KeyValueStore.toSchemaStore(store, setting.schema)
+        return Effect.orDie(s.get(setting.name))
+      },
+      capacity: Number.MAX_SAFE_INTEGER,
+    })
+
+    const get = <S extends Schema.Codec<any, any>>(
+      setting: Setting<string, S>,
+    ): Effect.Effect<Option.Option<S["Type"]>, never, S["DecodingServices"]> =>
+      Cache.get(cache, setting)
+
+    const set = <S extends Schema.Codec<any, any>>(
+      setting: Setting<string, S>,
+      value: Option.Option<S["Type"]>,
+    ): Effect.Effect<void, never, S["EncodingServices"]> => {
+      const s = KeyValueStore.toSchemaStore(store, setting.schema)
+      const setCache = Cache.set(cache, setting, value)
+      const update = Option.match(value, {
+        onNone: () => Effect.ignore(s.remove(setting.name)),
+        onSome: (v) => Effect.orDie(s.set(setting.name, v)),
+      })
+      return Effect.andThen(update, setCache)
+    }
+
+    return { get, set } as const
+  }),
+}) {
+  static layer = Layer.effect(this, this.make).pipe(Layer.provide(layerKvs))
+}
+
+export class Setting<
+  const Name extends string,
+  S extends Schema.Codec<any, any>,
+> {
+  readonly name: Name
+  readonly schema: S
+  constructor(name: Name, schema: S) {
+    this.name = name
+    this.schema = schema
+  }
+
+  get = Settings.use((s) => s.get(this))
+
+  set(value: Option.Option<S["Type"]>) {
+    return Settings.use((s) => s.set(this, value))
+  }
+}
+
+export const selectedTeamId = new Setting("selectedTeamId", Schema.String)
+
+export const selectedLabelId = new Setting("selectedLabelId", Schema.String)
+
+export const selectedCliAgentId = new Setting(
+  "selectedCliAgentId",
+  Schema.Literals(allCliAgents.map((a) => a.id)),
+)

package/src/cli.ts

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+
+import { Command, Flag } from "effect/unstable/cli"
+import { Effect, Layer, Option } from "effect"
+import { NodeRuntime, NodeServices } from "@effect/platform-node"
+import { CurrentProject, labelSelect, Linear } from "./Linear.ts"
+import { layerKvs } from "./Kvs.ts"
+import { Settings } from "./Settings.ts"
+import { run, selectCliAgent } from "./Runner.ts"
+
+const selectProject = Command.make("select-project").pipe(
+  Command.withDescription("Select the current Linear project"),
+  Command.withHandler(
+    Effect.fnUntraced(
+      function* () {
+        const project = yield* CurrentProject.select
+        yield* Effect.log(
+          `Selected Linear Project: ${project.name} (${project.id})`,
+        )
+      },
+      Effect.provide([layerKvs, Linear.layer]),
+    ),
+  ),
+)
+
+const selectLabel = Command.make("select-label").pipe(
+  Command.withDescription("Select the label to filter issues by"),
+  Command.withHandler(
+    Effect.fnUntraced(function* () {
+      const label = yield* labelSelect
+      yield* Effect.log(
+        `Selected Label: ${Option.match(label, {
+          onNone: () => "No Label",
+          onSome: (l) => l.name,
+        })}`,
+      )
+    }, Effect.provide(Linear.layer)),
+  ),
+)
+
+const selectAgent = Command.make("select-agent").pipe(
+  Command.withDescription("Select the CLI agent to use"),
+  Command.withHandler(() => selectCliAgent),
+)
+
+const iterations = Flag.integer("iterations").pipe(
+  Flag.withAlias("i"),
+  Flag.withDefault(1),
+)
+
+const root = Command.make("lalph", { iterations }).pipe(
+  Command.withHandler(
+    Effect.fnUntraced(function* ({ iterations }) {
+      yield* Effect.log(`Executing ${iterations} iteration(s)`)
+
+      for (let i = 0; i < iterations; i++) {
+        yield* run
+      }
+    }),
+  ),
+  Command.withSubcommands([selectProject, selectLabel, selectAgent]),
+)
+
+Command.run(root, {
+  version: "0.1.0",
+}).pipe(
+  Effect.provide(Settings.layer.pipe(Layer.provideMerge(NodeServices.layer))),
+  NodeRuntime.runMain,
+)

package/src/domain/CliAgent.ts

@@ -0,0 +1,43 @@
+import { Data } from "effect"
+
+export class CliAgent extends Data.Class<{
+  id: string
+  name: string
+  command: (options: {
+    readonly prompt: string
+    readonly prdFilePath: string
+    readonly progressFilePath: string
+  }) => ReadonlyArray<string>
+}> {}
+
+export const opencode = new CliAgent({
+  id: "opencode",
+  name: "opencode",
+  command: ({ prompt, prdFilePath, progressFilePath }) => [
+    "npx",
+    "-y",
+    "opencode-ai@latest",
+    "run",
+    prompt,
+    "-f",
+    prdFilePath,
+    "-f",
+    progressFilePath,
+  ],
+})
+
+export const claude = new CliAgent({
+  id: "claude",
+  name: "Claude Code",
+  command: ({ prompt, prdFilePath, progressFilePath }) => [
+    "npx",
+    "-y",
+    "@anthropic-ai/claude-code@latest",
+    "-p",
+    `@${prdFilePath} @${progressFilePath}
+
+${prompt}`,
+  ],
+})
+
+export const allCliAgents = [opencode, claude]