lalph 0.1.113 → 0.2.0

package/src/commands/projects/edit.ts

@@ -0,0 +1,62 @@
+import { Array, Effect, Option, pipe, String } from "effect"
+import { Command, Prompt } from "effect/unstable/cli"
+import { allProjects, getAllProjects, selectProject } from "../../Projects.ts"
+import { CurrentProjectId, Settings } from "../../Settings.ts"
+import { Project } from "../../domain/Project.ts"
+import { IssueSource } from "../../IssueSource.ts"
+import { CurrentIssueSource } from "../../IssueSources.ts"
+
+export const commandProjectsEdit = Command.make("edit").pipe(
+  Command.withDescription("Modify a project"),
+  Command.withHandler(
+    Effect.fnUntraced(function* () {
+      const projects = yield* getAllProjects
+      const project = yield* selectProject
+      const concurrency = yield* Prompt.integer({
+        message: "Concurrency",
+        min: 1,
+      })
+      const targetBranch = pipe(
+        yield* Prompt.text({
+          message: "Target branch (leave empty to use HEAD)",
+        }),
+        String.trim,
+        Option.liftPredicate(String.isNonEmpty),
+      )
+      const gitFlow = yield* Prompt.select({
+        message: "Git flow",
+        choices: [
+          { title: "Pull Request", value: "pr" },
+          { title: "Commit", value: "commit" },
+        ] as const,
+      })
+      const reviewAgent = yield* Prompt.toggle({
+        message: "Enable review agent?",
+      })
+
+      const nextProject = new Project({
+        ...project,
+        concurrency,
+        targetBranch,
+        gitFlow,
+        reviewAgent,
+      })
+      yield* Settings.set(
+        allProjects,
+        Option.some(
+          Array.map(projects, (p) =>
+            p.id === nextProject.id ? nextProject : p,
+          ),
+        ),
+      )
+
+      const source = yield* IssueSource
+      yield* source.reset.pipe(
+        Effect.provideService(CurrentProjectId, nextProject.id),
+      )
+      yield* source.settings(project.id)
+    }),
+  ),
+  Command.provide(Settings.layer),
+  Command.provide(CurrentIssueSource.layer),
+)

package/src/commands/projects/ls.ts

@@ -0,0 +1,38 @@
+import { Effect, Option } from "effect"
+import { Command } from "effect/unstable/cli"
+import { IssueSource } from "../../IssueSource.ts"
+import { CurrentIssueSource } from "../../IssueSources.ts"
+import { getAllProjects } from "../../Projects.ts"
+import { Settings } from "../../Settings.ts"
+
+export const commandProjectsLs = Command.make("ls").pipe(
+  Command.withDescription("List all configured projects and their settings"),
+  Command.withHandler(
+    Effect.fnUntraced(function* () {
+      const meta = yield* CurrentIssueSource
+      const source = yield* IssueSource
+      console.log("Issue source:", meta.name)
+      console.log("")
+
+      const projects = yield* getAllProjects
+
+      for (const project of projects) {
+        console.log(`Project: ${project.id}`)
+        yield* source.info(project.id)
+        console.log(`  Concurrency: ${project.concurrency}`)
+        if (Option.isSome(project.targetBranch)) {
+          console.log(`  Target Branch: ${project.targetBranch.value}`)
+        }
+        console.log(
+          `  Git flow: ${project.gitFlow === "pr" ? "Pull Request" : "Commit"}`,
+        )
+        console.log(
+          `  Review agent: ${project.reviewAgent ? "Enabled" : "Disabled"}`,
+        )
+        console.log("")
+      }
+    }),
+  ),
+  Command.provide(Settings.layer),
+  Command.provide(CurrentIssueSource.layer),
+)

package/src/commands/projects/rm.ts

@@ -0,0 +1,22 @@
+import { Array, Effect, Option } from "effect"
+import { Command } from "effect/unstable/cli"
+import { allProjects, getAllProjects, selectProject } from "../../Projects.ts"
+import { Settings } from "../../Settings.ts"
+
+export const commandProjectsRm = Command.make("rm").pipe(
+  Command.withDescription("Remove a project"),
+  Command.withHandler(
+    Effect.fnUntraced(function* () {
+      const projects = yield* getAllProjects
+      const project = yield* selectProject
+      const newProjects = projects.filter((p) => p.id !== project.id)
+      if (!Array.isArrayNonEmpty(newProjects)) {
+        return yield* Effect.log(
+          "You cannot remove the last remaining project.",
+        )
+      }
+      yield* Settings.set(allProjects, Option.some(newProjects))
+    }),
+  ),
+  Command.provide(Settings.layer),
+)

package/src/commands/projects/toggle.ts

@@ -0,0 +1,37 @@
+import { Array, Effect, Option } from "effect"
+import { Command, Prompt } from "effect/unstable/cli"
+import { allProjects, getAllProjects } from "../../Projects.ts"
+import { Settings } from "../../Settings.ts"
+import { Project } from "../../domain/Project.ts"
+
+export const commandProjectsToggle = Command.make("toggle").pipe(
+  Command.withDescription("Enable or disable projects"),
+  Command.withHandler(
+    Effect.fnUntraced(function* () {
+      const projects = yield* getAllProjects
+      const enabled = yield* Prompt.multiSelect({
+        message: "Select projects to enable",
+        choices: projects.map((project) => ({
+          title: project.id,
+          value: project.id,
+          selected: project.enabled,
+        })),
+      })
+
+      yield* Settings.set(
+        allProjects,
+        Option.some(
+          Array.map(
+            projects,
+            (p) =>
+              new Project({
+                ...p,
+                enabled: enabled.includes(p.id),
+              }),
+          ),
+        ),
+      )
+    }),
+  ),
+  Command.provide(Settings.layer),
+)

package/src/commands/projects.ts

@@ -0,0 +1,24 @@
+import { Command } from "effect/unstable/cli"
+import { commandProjectsLs } from "./projects/ls.ts"
+import { commandProjectsAdd } from "./projects/add.ts"
+import { commandProjectsRm } from "./projects/rm.ts"
+import { commandProjectsEdit } from "./projects/edit.ts"
+import { commandProjectsToggle } from "./projects/toggle.ts"
+
+const subcommands = Command.withSubcommands([
+  commandProjectsLs,
+  commandProjectsAdd,
+  commandProjectsEdit,
+  commandProjectsToggle,
+  commandProjectsRm,
+])
+
+export const commandProjects = Command.make("projects").pipe(
+  Command.withDescription("Manage projects"),
+  subcommands,
+)
+
+export const commandProjectsAlias = Command.make("p").pipe(
+  Command.withDescription("Alias for 'projects' command"),
+  subcommands,
+)

package/src/commands/root.ts

@@ -16,7 +16,7 @@ import { Prd } from "../Prd.ts"
 import { ChildProcess } from "effect/unstable/process"
 import { Worktree } from "../Worktree.ts"
 import { getCommandPrefix, getOrSelectCliAgent } from "./agent.ts"
-import { Flag, CliError, Command } from "effect/unstable/cli"
+import { Flag, Command } from "effect/unstable/cli"
 import { IssueSource } from "../IssueSource.ts"
 import {
   checkForWork,
@@ -29,7 +29,7 @@ import { agentChooser } from "../Agents/chooser.ts"
 import { RunnerStalled } from "../domain/Errors.ts"
 import { agentReviewer } from "../Agents/reviewer.ts"
 import { agentTimeout } from "../Agents/timeout.ts"
-import { Settings } from "../Settings.ts"
+import { CurrentProjectId, Settings } from "../Settings.ts"
 import { Atom, AtomRegistry, Reactivity } from "effect/unstable/reactivity"
 import {
   activeWorkerLoggingAtom,
@@ -39,6 +39,8 @@ import {
 import { WorkerStatus } from "../domain/WorkerState.ts"
 import { GitFlow, GitFlowCommit, GitFlowPR } from "../GitFlow.ts"
 import { parseBranch } from "../shared/git.ts"
+import { getAllProjects } from "../Projects.ts"
+import type { Project } from "../domain/Project.ts"
 
 // Main iteration run logic
 
@@ -54,6 +56,7 @@ const run = Effect.fnUntraced(
     ) => ChildProcess.Command
     readonly review: boolean
   }) {
+    const projectId = yield* CurrentProjectId
     const fs = yield* FileSystem.FileSystem
     const pathService = yield* Path.Path
     const worktree = yield* Worktree
@@ -127,7 +130,7 @@ const run = Effect.fnUntraced(
     yield* prd.setChosenIssueId(taskId)
     yield* prd.setAutoMerge(chosenTask.prd.autoMerge)
 
-    yield* source.ensureInProgress(taskId).pipe(
+    yield* source.ensureInProgress(projectId, taskId).pipe(
       Effect.timeoutOrElse({
         duration: "1 minute",
         onTimeout: () => Effect.fail(new RunnerStalled()),
@@ -221,6 +224,111 @@ const run = Effect.fnUntraced(
   Effect.provide(Prd.layer, { local: true }),
 )
 
+const runProject = Effect.fnUntraced(
+  function* (options: {
+    readonly iterations: number
+    readonly project: Project
+    readonly specsDirectory: string
+    readonly stallTimeout: Duration.Duration
+    readonly runTimeout: Duration.Duration
+    readonly commandPrefix: (
+      command: ChildProcess.Command,
+    ) => ChildProcess.Command
+  }) {
+    const isFinite = Number.isFinite(options.iterations)
+    const iterationsDisplay = isFinite ? options.iterations : "unlimited"
+    const semaphore = Effect.makeSemaphoreUnsafe(options.project.concurrency)
+    const fibers = yield* FiberSet.make()
+
+    yield* resetInProgress.pipe(Effect.withSpan("Main.resetInProgress"))
+
+    yield* Effect.log(
+      `Executing ${iterationsDisplay} iteration(s) with concurrency ${options.project.concurrency}`,
+    )
+
+    let iterations = options.iterations
+    let iteration = 0
+    let quit = false
+
+    yield* Atom.mount(activeWorkerLoggingAtom)
+
+    while (true) {
+      yield* semaphore.take(1)
+      if (quit || (isFinite && iteration >= iterations)) {
+        break
+      }
+
+      const currentIteration = iteration
+
+      const startedDeferred = yield* Deferred.make<void>()
+
+      yield* checkForWork.pipe(
+        Effect.andThen(
+          run({
+            startedDeferred,
+            targetBranch: options.project.targetBranch,
+            specsDirectory: options.specsDirectory,
+            stallTimeout: options.stallTimeout,
+            runTimeout: options.runTimeout,
+            commandPrefix: options.commandPrefix,
+            review: options.project.reviewAgent,
+          }).pipe(
+            Effect.provide(
+              options.project.gitFlow === "commit" ? GitFlowCommit : GitFlowPR,
+              { local: true },
+            ),
+            withWorkerState(options.project.id),
+          ),
+        ),
+        Effect.catchFilter(
+          (e) =>
+            e._tag === "NoMoreWork" || e._tag === "QuitError"
+              ? Filter.fail(e)
+              : e,
+          (e) =>
+            Effect.logWarning(Cause.fail(e)).pipe(
+              Effect.andThen(Effect.sleep(Duration.seconds(10))),
+            ),
+        ),
+        Effect.catchTags({
+          NoMoreWork(_) {
+            if (isFinite) {
+              // If we have a finite number of iterations, we exit when no more
+              // work is found
+              iterations = currentIteration
+              return Effect.log(
+                `No more work to process, ending after ${currentIteration} iteration(s).`,
+              )
+            }
+            const log =
+              Iterable.size(fibers) <= 1
+                ? Effect.log("No more work to process, waiting 30 seconds...")
+                : Effect.void
+            return Effect.andThen(log, Effect.sleep(Duration.seconds(30)))
+          },
+          QuitError(_) {
+            quit = true
+            return Effect.void
+          },
+        }),
+        Effect.ensuring(semaphore.release(1)),
+        Effect.ensuring(Deferred.completeWith(startedDeferred, Effect.void)),
+        FiberSet.run(fibers),
+      )
+
+      yield* Deferred.await(startedDeferred)
+
+      iteration++
+    }
+
+    yield* FiberSet.awaitEmpty(fibers)
+  },
+  (effect, options) =>
+    Effect.annotateLogs(effect, {
+      project: options.project.id,
+    }),
+)
+
 // Command
 
 const iterations = Flag.integer("iterations").pipe(
@@ -229,37 +337,6 @@ const iterations = Flag.integer("iterations").pipe(
   Flag.withDefault(Number.POSITIVE_INFINITY),
 )
 
-const concurrency = Flag.integer("concurrency").pipe(
-  Flag.withDescription("Number of concurrent agents, defaults to 1"),
-  Flag.withAlias("c"),
-  Flag.withDefault(1),
-)
-
-const targetBranch = Flag.string("target-branch").pipe(
-  Flag.withDescription(
-    "Target branch for PRs. Defaults to current branch. Env variable: LALPH_TARGET_BRANCH",
-  ),
-  Flag.withAlias("b"),
-  Flag.withFallbackConfig(Config.string("LALPH_TARGET_BRANCH")),
-  Flag.withDefault(
-    ChildProcess.make`git branch --show-current`.pipe(
-      ChildProcess.string,
-      Effect.orDie,
-      Effect.flatMap((output) => {
-        const branch = output.trim()
-        return branch === ""
-          ? Effect.fail(
-              new CliError.MissingOption({
-                option: "--target-branch",
-              }),
-            )
-          : Effect.succeed(branch)
-      }),
-    ),
-  ),
-  Flag.optional,
-)
-
 const maxIterationMinutes = Flag.integer("max-minutes").pipe(
   Flag.withDescription(
     "Maximum number of minutes to allow an iteration to run. Defaults to 90 minutes. Env variable: LALPH_MAX_MINUTES",
@@ -285,36 +362,15 @@ const specsDirectory = Flag.directory("specs").pipe(
   Flag.withDefault(".specs"),
 )
 
-const commitMode = Flag.boolean("commit").pipe(
-  Flag.withDescription("Commit to the target branch instead of creating PRs"),
-)
-
 const verbose = Flag.boolean("verbose").pipe(
   Flag.withDescription("Enable verbose logging"),
   Flag.withAlias("v"),
 )
 
-const review = Flag.boolean("review").pipe(
-  Flag.withDescription(
-    "Enable the AI peer-review step. Will use LALPH_REVIEW.md if present.",
-  ),
-)
-
-// handled in cli.ts
-const reset = Flag.boolean("reset").pipe(
-  Flag.withDescription("Reset the current issue source before running"),
-  Flag.withAlias("r"),
-)
-
 export const commandRoot = Command.make("lalph", {
   iterations,
-  concurrency,
-  targetBranch,
   maxIterationMinutes,
   stallMinutes,
-  commitMode,
-  reset,
-  review,
   specsDirectory,
   verbose,
 }).pipe(
@@ -322,110 +378,26 @@ export const commandRoot = Command.make("lalph", {
     Effect.fnUntraced(
       function* ({
         iterations,
-        concurrency,
-        targetBranch,
         maxIterationMinutes,
         stallMinutes,
         specsDirectory,
-        review,
-        commitMode,
       }) {
         const commandPrefix = yield* getCommandPrefix
         yield* getOrSelectCliAgent
-
-        const isFinite = Number.isFinite(iterations)
-        const iterationsDisplay = isFinite ? iterations : "unlimited"
-        const runConcurrency = Math.max(1, concurrency)
-        const semaphore = Effect.makeSemaphoreUnsafe(runConcurrency)
-        const fibers = yield* FiberSet.make()
-
-        yield* resetInProgress.pipe(Effect.withSpan("Main.resetInProgress"))
-
-        yield* Effect.log(
-          `Executing ${iterationsDisplay} iteration(s) with concurrency ${runConcurrency}`,
+        const projects = (yield* getAllProjects).filter((p) => p.enabled)
+        yield* Effect.forEach(
+          projects,
+          (project) =>
+            runProject({
+              iterations,
+              project,
+              specsDirectory,
+              stallTimeout: Duration.minutes(stallMinutes),
+              runTimeout: Duration.minutes(maxIterationMinutes),
+              commandPrefix,
+            }).pipe(Effect.provideService(CurrentProjectId, project.id)),
+          { concurrency: "unbounded", discard: true },
         )
-        if (Option.isSome(targetBranch)) {
-          yield* Effect.log(`Using target branch: ${targetBranch.value}`)
-        }
-
-        let iteration = 0
-        let quit = false
-
-        yield* Atom.mount(activeWorkerLoggingAtom)
-
-        while (true) {
-          yield* semaphore.take(1)
-          if (quit || (isFinite && iteration >= iterations)) {
-            break
-          }
-
-          const currentIteration = iteration
-
-          const startedDeferred = yield* Deferred.make<void>()
-
-          yield* checkForWork.pipe(
-            Effect.andThen(
-              run({
-                startedDeferred,
-                targetBranch,
-                specsDirectory,
-                stallTimeout: Duration.minutes(stallMinutes),
-                runTimeout: Duration.minutes(maxIterationMinutes),
-                commandPrefix,
-                review,
-              }).pipe(
-                Effect.provide(commitMode ? GitFlowCommit : GitFlowPR, {
-                  local: true,
-                }),
-                withWorkerState(currentIteration),
-              ),
-            ),
-            Effect.catchFilter(
-              (e) =>
-                e._tag === "NoMoreWork" || e._tag === "QuitError"
-                  ? Filter.fail(e)
-                  : e,
-              (e) => Effect.logWarning(Cause.fail(e)),
-            ),
-            Effect.catchTags({
-              NoMoreWork(_) {
-                if (isFinite) {
-                  // If we have a finite number of iterations, we exit when no more
-                  // work is found
-                  iterations = currentIteration
-                  return Effect.log(
-                    `No more work to process, ending after ${currentIteration} iteration(s).`,
-                  )
-                }
-                const log =
-                  Iterable.size(fibers) <= 1
-                    ? Effect.log(
-                        "No more work to process, waiting 30 seconds...",
-                      )
-                    : Effect.void
-                return Effect.andThen(log, Effect.sleep(Duration.seconds(30)))
-              },
-              QuitError(_) {
-                quit = true
-                return Effect.void
-              },
-            }),
-            Effect.annotateLogs({
-              iteration: currentIteration,
-            }),
-            Effect.ensuring(semaphore.release(1)),
-            Effect.ensuring(
-              Deferred.completeWith(startedDeferred, Effect.void),
-            ),
-            FiberSet.run(fibers),
-          )
-
-          yield* Deferred.await(startedDeferred)
-
-          iteration++
-        }
-
-        yield* FiberSet.awaitEmpty(fibers)
       },
       Effect.scoped,
       Effect.provide([

package/src/commands/{shell.ts → sh.ts}

@@ -1,10 +1,11 @@
 import { Command } from "effect/unstable/cli"
-import { Effect, FileSystem, Path } from "effect"
+import { Effect, FileSystem, Layer, Path } from "effect"
 import { ChildProcess } from "effect/unstable/process"
 import { Prd } from "../Prd.ts"
 import { Worktree } from "../Worktree.ts"
+import { layerProjectIdPrompt } from "../Projects.ts"
 
-export const commandShell = Command.make("shell").pipe(
+export const commandSh = Command.make("sh").pipe(
   Command.withDescription("Enter an interactive shell in the worktree"),
   Command.withHandler(
     Effect.fnUntraced(
@@ -18,6 +19,10 @@ export const commandShell = Command.make("shell").pipe(
           pathService.resolve(pathService.join(".lalph", "config")),
           pathService.join(worktree.directory, ".lalph", "config"),
         )
+        yield* fs.symlink(
+          pathService.resolve(pathService.join(".lalph", "projects")),
+          pathService.join(worktree.directory, ".lalph", "projects"),
+        )
 
         yield* ChildProcess.make(process.env.SHELL || "/bin/bash", [], {
           cwd: worktree.directory,
@@ -27,7 +32,9 @@ export const commandShell = Command.make("shell").pipe(
         }).pipe(ChildProcess.exitCode)
       },
       Effect.scoped,
-      Effect.provide(Prd.layerProvided),
+      Effect.provide(
+        Prd.layerProvided.pipe(Layer.provideMerge(layerProjectIdPrompt)),
+      ),
     ),
   ),
 )

package/src/domain/Project.ts

@@ -0,0 +1,22 @@
+import { Option, Schema } from "effect"
+
+export const ProjectId = Schema.String.pipe(Schema.brand("lalph/ProjectId"))
+export type ProjectId = typeof ProjectId.Type
+
+export class Project extends Schema.Class<Project>("lalph/Project")({
+  id: ProjectId,
+  enabled: Schema.Boolean,
+  targetBranch: Schema.Option(Schema.String),
+  concurrency: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)),
+  gitFlow: Schema.Literals(["pr", "commit"]),
+  reviewAgent: Schema.Boolean,
+}) {
+  static defaultProject = new Project({
+    id: ProjectId.makeUnsafe("default"),
+    enabled: true,
+    targetBranch: Option.none(),
+    concurrency: 1,
+    gitFlow: "pr",
+    reviewAgent: true,
+  })
+}

package/src/domain/WorkerState.ts

@@ -1,13 +1,18 @@
 import { Data, DateTime, Exit } from "effect"
+import type { ProjectId } from "./Project.ts"
 
 export class WorkerState extends Data.Class<{
-  iteration: number
+  id: number
+  projectId: ProjectId
   status: WorkerStatus
   lastTransitionAt: DateTime.Utc
 }> {
-  static initial(iteration: number) {
+  static initial(options: {
+    readonly projectId: ProjectId
+    readonly id: number
+  }) {
     return new WorkerState({
-      iteration,
+      ...options,
       status: WorkerStatus.Booting(),
       lastTransitionAt: DateTime.nowUnsafe(),
     })
@@ -15,7 +20,7 @@ export class WorkerState extends Data.Class<{
 
   transitionTo(status: WorkerStatus): WorkerState {
     return new WorkerState({
-      iteration: this.iteration,
+      ...this,
       status,
       lastTransitionAt: DateTime.nowUnsafe(),
     })