@qotaq/lalphgram 0.1.2 → 0.1.4

package/src/Main.ts

@@ -6,7 +6,7 @@
 import { Command as CliCommand, Options, Prompt } from "@effect/cli"
 import { Command as PlatformCommand, FetchHttpClient, FileSystem, Path } from "@effect/platform"
 import { NodeContext, NodeRuntime } from "@effect/platform-node"
-import { Config, Console, Effect, Layer, Logger, LogLevel, Option, Stream } from "effect"
+import { Config, Console, Effect, Layer, Logger, LogLevel, Option, Schema, Stream } from "effect"
 import { fileURLToPath } from "node:url"
 import { AppContext, AppContextLive } from "./services/AppContext.js"
 import { AppRuntimeConfig, RuntimeConfig } from "./services/AppRuntimeConfig.js"
@@ -17,7 +17,7 @@ import { PlanCommandBuilder } from "./services/PlanSession.js"
 import { TelegramConfig, TelegramConfigLive, TelegramConfigSchema } from "./services/TelegramConfig.js"
 
 const lalphNotifyCommand = CliCommand.make(
-  "lalph-notify",
+  "lalphgram",
   {
     interval: Options.integer("interval").pipe(
       Options.withDefault(30),
@@ -156,9 +156,14 @@ const lalphNotifyCommand = CliCommand.make(
     })
 ).pipe(CliCommand.withDescription("Zero-config notification service using lalph project config"))
 
-const cli = CliCommand.run(lalphNotifyCommand, {
-  name: "lalph-notify",
-  version: "1.0.0"
+const PackageJsonVersion = Schema.Struct({ version: Schema.String })
+
+const readVersion = Effect.gen(function*() {
+  const fs = yield* FileSystem.FileSystem
+  const pathService = yield* Path.Path
+  const dir = pathService.dirname(fileURLToPath(import.meta.url))
+  const content = yield* fs.readFileString(pathService.join(dir, "..", "..", "package.json"))
+  return Schema.decodeUnknownSync(PackageJsonVersion)(JSON.parse(content)).version
 })
 
 const logLevelLayer = Layer.unwrapEffect(
@@ -168,7 +173,14 @@ const logLevelLayer = Layer.unwrapEffect(
   )
 )
 
-Effect.suspend(() => cli(process.argv)).pipe(
+Effect.gen(function*() {
+  const version = yield* readVersion
+  const cli = CliCommand.run(lalphNotifyCommand, {
+    name: "lalphgram",
+    version
+  })
+  yield* Effect.suspend(() => cli(process.argv))
+}).pipe(
   Effect.provide(TelegramConfigLive),
   Effect.provide(AppContextLive),
   Effect.provide(FetchHttpClient.layer),

package/src/lib/AnalysisPrompts.ts

@@ -13,6 +13,7 @@ export const getAnalysisPrompt = (planType: string): string => {
   switch (planType) {
     case "Feature":
       return `\
+
 Now analyze the spec you just wrote. Create the following files:
 
 1. \`.specs/analysis.md\` — high-level design summary in plain text:
@@ -28,6 +29,7 @@ Now analyze the spec you just wrote. Create the following files:
    - **Act**: the single effect/function call under test
    - **Assert**: expected outcome and why this case matters
 
+Be extremely concise. Sacrifice grammar for the sake of concision.
 Do NOT display file contents in your response. The system will send them to the user.`
     case "Bug":
       return `\

package/src/schemas/ProjectSchemas.ts

@@ -14,5 +14,6 @@ export class LalphProject extends Schema.Class<LalphProject>("LalphProject")({
   targetBranch: Schema.Option(Schema.String),
   concurrency: Schema.Int.pipe(Schema.positive()),
   gitFlow: Schema.Literal("pr", "commit"),
-  reviewAgent: Schema.Boolean
+  reviewAgent: Schema.Boolean,
+  labelFilter: Schema.optionalWith(Schema.String, { default: () => "lalph" })
 }) {}

package/src/services/AutoMerge.ts

@@ -43,11 +43,31 @@ const makeRepoFromFullName = (fullName: string) =>
     html_url: ""
   })
 
-const isCISuccess = (state: string, checkRuns: ReadonlyArray<{ readonly conclusion: string | null }>) => {
-  if (checkRuns.length === 0) return state !== "failure"
-  const allChecksCompleted = Array.every(checkRuns, (cr) => cr.conclusion !== null)
-  const allChecksPassed = Array.every(checkRuns, (cr) => cr.conclusion === "success" || cr.conclusion === "skipped")
-  return allChecksCompleted && allChecksPassed && state !== "failure"
+const isBillingFailure = (checkRun: {
+  readonly conclusion: string | null
+  readonly output: { readonly summary: string | null } | null
+}) =>
+  checkRun.conclusion === "failure" &&
+  checkRun.output?.summary !== null &&
+  checkRun.output?.summary !== undefined &&
+  (checkRun.output.summary.includes("account payments have failed") ||
+    checkRun.output.summary.includes("spending limit"))
+
+const isCISuccess = (
+  state: string,
+  checkRuns: ReadonlyArray<{
+    readonly conclusion: string | null
+    readonly output: { readonly summary: string | null } | null
+  }>
+) => {
+  const nonBillingRuns = Array.filter(checkRuns, (cr) => !isBillingFailure(cr))
+  if (nonBillingRuns.length === 0) return state !== "failure" || checkRuns.length > 0
+  const allChecksCompleted = Array.every(nonBillingRuns, (cr) => cr.conclusion !== null)
+  const allChecksPassed = Array.every(
+    nonBillingRuns,
+    (cr) => cr.conclusion === "success" || cr.conclusion === "skipped"
+  )
+  return allChecksCompleted && allChecksPassed
 }
 
 /**

package/src/services/ChatMachine.ts

@@ -471,11 +471,15 @@ export const chatMachine = Machine.make(
                 yield* Effect.log("Plan collection done, starting session").pipe(
                   Effect.annotateLogs("planText", joinedText)
                 )
-                const totalProjects = yield* projectStore.listProjects.pipe(
-                  Effect.map((ps) => ps.length),
-                  Effect.orElseSucceed(() => 1)
+                const projects = yield* projectStore.listProjects.pipe(
+                  Effect.orElseSucceed((): ReadonlyArray<{ id: string; labelFilter: string }> => [])
                 )
-                yield* planSession.start(joinedText, totalProjects > 1 ? state.projectId : undefined).pipe(
+                const currentProject = projects.find((p) => p.id === state.projectId)
+                yield* planSession.start(
+                  joinedText,
+                  projects.length > 1 ? state.projectId : undefined,
+                  projects.length > 1 ? currentProject?.labelFilter : undefined
+                ).pipe(
                   Effect.tapError((err) => notifier.sendMessage(`Plan error: ${err.message}`)),
                   Effect.orElseSucceed(() => undefined)
                 )

package/src/services/GitHubClient.ts

@@ -25,6 +25,7 @@ export interface GitHubCheckRun {
   readonly status: string
   readonly conclusion: string | null
   readonly html_url: string
+  readonly output: { readonly title: string | null; readonly summary: string | null } | null
 }
 
 /**
@@ -242,7 +243,8 @@ export const GitHubClientLive = Layer.effect(
             name: cr.name,
             status: cr.status,
             conclusion: cr.conclusion,
-            html_url: cr.htmlUrl
+            html_url: cr.htmlUrl,
+            output: cr.output
           }))
         })),
         Effect.mapError((err) =>

package/src/services/OctokitClient.ts

@@ -105,6 +105,7 @@ export interface OctokitCheckRun {
   readonly status: string
   readonly conclusion: string | null
   readonly htmlUrl: string
+  readonly output: { readonly title: string | null; readonly summary: string | null } | null
 }
 
 /**
@@ -548,7 +549,8 @@ export const OctokitClientLive = Layer.effect(
               name: cr.name,
               status: cr.status,
               conclusion: cr.conclusion ?? null,
-              htmlUrl: cr.html_url ?? ""
+              htmlUrl: cr.html_url ?? "",
+              output: cr.output ? { title: cr.output.title ?? null, summary: cr.output.summary ?? null } : null
             }))
           )
         )

package/src/services/PlanSession.ts

@@ -109,7 +109,11 @@ interface ActiveSession {
  * @category services
  */
 export interface PlanSessionService {
-  readonly start: (planText: string, projectId?: string | undefined) => Effect.Effect<void, PlanSessionError>
+  readonly start: (
+    planText: string,
+    projectId?: string | undefined,
+    labelFilter?: string | undefined
+  ) => Effect.Effect<void, PlanSessionError>
   readonly answer: (text: string) => Effect.Effect<void, PlanSessionError>
   readonly sendFollowUp: (text: string) => Effect.Effect<void, PlanSessionError>
   readonly interrupt: (text: string) => Effect.Effect<void, PlanSessionError>
@@ -196,7 +200,7 @@ export const PlanSessionLive = Layer.scoped(
 
     yield* Effect.addFinalizer(() => closeActiveSession)
 
-    const start = (planText: string, projectId?: string | undefined) =>
+    const start = (planText: string, projectId?: string | undefined, labelFilter?: string | undefined) =>
       Effect.gen(function*() {
         const current = yield* Ref.get(sessionRef)
         if (Option.isSome(current)) {
@@ -251,8 +255,9 @@ export const PlanSessionLive = Layer.scoped(
         if (projectId != null) {
           const encoder = new TextEncoder()
           yield* Queue.offer(stdinQueue, encoder.encode(projectId + "\n"))
-          yield* Effect.log("Pre-answered project prompt").pipe(
-            Effect.annotateLogs({ projectId })
+          yield* Queue.offer(stdinQueue, encoder.encode((labelFilter ?? "") + "\n"))
+          yield* Effect.log("Pre-answered project and label prompts").pipe(
+            Effect.annotateLogs({ projectId, labelFilter: labelFilter ?? "(empty)" })
           )
         }