@qotaq/lalphgram 0.1.0

package/src/services/TaskTracker/TaskTracker.ts

@@ -0,0 +1,34 @@
+/**
+ * TaskTracker service interface for task tracking backends
+ * @since 1.0.0
+ */
+import type { Effect, Stream } from "effect"
+import { Context, Data } from "effect"
+import type { TaskTrackerEvent } from "../../Events.js"
+import type { TrackerIssue } from "../../schemas/TrackerSchemas.js"
+
+/**
+ * @since 1.0.0
+ * @category errors
+ */
+export class TaskTrackerError extends Data.TaggedError("TaskTrackerError")<{
+  message: string
+  cause: unknown
+}> {}
+
+/**
+ * @since 1.0.0
+ * @category services
+ */
+export interface TaskTrackerService {
+  readonly eventStream: Stream.Stream<TaskTrackerEvent, TaskTrackerError>
+  readonly moveToTodo: (issueId: string) => Effect.Effect<void, TaskTrackerError>
+  readonly setPriorityUrgent: (issueId: string) => Effect.Effect<void, TaskTrackerError>
+  readonly getIssue: (issueId: string) => Effect.Effect<TrackerIssue, TaskTrackerError>
+}
+
+/**
+ * @since 1.0.0
+ * @category context
+ */
+export class TaskTracker extends Context.Tag("TaskTracker")<TaskTracker, TaskTrackerService>() {}

package/src/services/TelegramConfig.ts

@@ -0,0 +1,120 @@
+/**
+ * Telegram config persistence service following lalph TokenManager pattern
+ * @since 1.0.0
+ */
+import { FileSystem, Path } from "@effect/platform"
+import { Context, Data, Effect, Layer, Option, Schema } from "effect"
+import { AppContext } from "./AppContext.js"
+
+/**
+ * @since 1.0.0
+ * @category schemas
+ */
+export class TelegramConfigSchema extends Schema.Class<TelegramConfigSchema>("TelegramConfigSchema")({
+  botToken: Schema.String,
+  chatId: Schema.NullOr(Schema.String)
+}) {}
+
+/**
+ * @since 1.0.0
+ * @category errors
+ */
+export class TelegramConfigError extends Data.TaggedError("TelegramConfigError")<{
+  message: string
+  cause: unknown
+}> {}
+
+/**
+ * @since 1.0.0
+ * @category services
+ */
+export interface TelegramConfigService {
+  readonly get: Effect.Effect<Option.Option<TelegramConfigSchema>>
+  readonly set: (config: TelegramConfigSchema) => Effect.Effect<void, TelegramConfigError>
+}
+
+/**
+ * @since 1.0.0
+ * @category context
+ */
+export class TelegramConfig extends Context.Tag("TelegramConfig")<
+  TelegramConfig,
+  TelegramConfigService
+>() {}
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const TelegramConfigLive = Layer.effect(
+  TelegramConfig,
+  Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem
+    const pathService = yield* Path.Path
+    const appContext = yield* AppContext
+
+    const filePath = pathService.join(appContext.configDir, encodeURIComponent("notify.telegram"))
+
+    let currentConfig: TelegramConfigSchema | null = null
+
+    const get = Effect.gen(function*() {
+      if (currentConfig !== null) return Option.some(currentConfig)
+
+      const content = yield* fs.readFileString(filePath).pipe(
+        Effect.mapError((err) =>
+          new TelegramConfigError({
+            message: "Failed to read telegram config",
+            cause: err
+          })
+        )
+      )
+      const json = yield* Effect.try({
+        try: () => JSON.parse(content),
+        catch: (err) =>
+          new TelegramConfigError({
+            message: "Failed to parse telegram config",
+            cause: err
+          })
+      })
+      const config = yield* Schema.decodeUnknown(TelegramConfigSchema)(json).pipe(
+        Effect.mapError((err) =>
+          new TelegramConfigError({
+            message: "Failed to decode telegram config",
+            cause: err
+          })
+        )
+      )
+      currentConfig = config
+      return Option.some(config)
+    }).pipe(
+      Effect.catchTag(
+        "TelegramConfigError",
+        (err) =>
+          Effect.logWarning(`No stored Telegram config: ${err.message}`).pipe(
+            Effect.map(() => Option.none<TelegramConfigSchema>())
+          )
+      )
+    )
+
+    const set = (config: TelegramConfigSchema) =>
+      Effect.gen(function*() {
+        yield* fs.writeFileString(
+          filePath,
+          JSON.stringify({
+            botToken: config.botToken,
+            chatId: config.chatId
+          })
+        ).pipe(
+          Effect.mapError((err) =>
+            new TelegramConfigError({
+              message: "Failed to write telegram config",
+              cause: err
+            })
+          )
+        )
+        currentConfig = config
+      })
+
+    return TelegramConfig.of({ get, set })
+  })
+)

package/src/services/TrackerLayerMap.ts

@@ -0,0 +1,19 @@
+/**
+ * Dynamic layer map for selecting TaskTracker implementation at runtime
+ * @since 1.0.0
+ */
+import { Layer, LayerMap } from "effect"
+import { LinearSdkClientLive } from "./LinearSdkClient.js"
+import { GitHubIssueTrackerLive } from "./TaskTracker/GitHubIssueTracker.js"
+import { LinearTrackerLive } from "./TaskTracker/LinearTracker.js"
+
+/**
+ * @since 1.0.0
+ * @category layer-map
+ */
+export class TrackerLayerMap extends LayerMap.Service<TrackerLayerMap>()("TrackerLayerMap", {
+  layers: {
+    linear: LinearTrackerLive.pipe(Layer.provide(LinearSdkClientLive)),
+    github: GitHubIssueTrackerLive
+  }
+}) {}

package/src/shim/bin.ts

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+/**
+ * Entry point for the claude-shim binary.
+ * @since 1.0.0
+ */
+import { query } from "@anthropic-ai/claude-agent-sdk"
+import { NodeRuntime } from "@effect/platform-node"
+import * as NodeSink from "@effect/platform-node/NodeSink"
+import * as NodeStream from "@effect/platform-node/NodeStream"
+import { Effect, Layer } from "effect"
+import { ClaudeQuery, ShimDeps, ShimError, shimProgram } from "./main.js"
+
+shimProgram.pipe(
+  Effect.tapError(() =>
+    Effect.sync(() => {
+      process.exitCode = 1
+    })
+  ),
+  Effect.catchAll((err) => Effect.logError("claude-shim failed", err)),
+  Effect.provide(Layer.mergeAll(
+    Layer.succeed(ShimDeps, {
+      args: process.argv.slice(2),
+      stdin: NodeStream.stdin,
+      stdout: NodeSink.stdout,
+      stderr: NodeSink.stderr
+    }),
+    Layer.succeed(ClaudeQuery, {
+      create: (params) =>
+        Effect.try({
+          try: () => query(params),
+          catch: (err) => new ShimError({ message: "Failed to create query", cause: err })
+        })
+    })
+  )),
+  NodeRuntime.runMain
+)

package/src/shim/main.ts

@@ -0,0 +1,255 @@
+/**
+ * SDK-based claude binary replacement — outputs stream-json NDJSON to stdout
+ * for PlanSession to parse. Uses MCP tool for AskUserQuestion instead of hooks.
+ * @since 1.0.0
+ */
+import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk"
+import type { Query, query, SDKMessage, SDKUserMessage } from "@anthropic-ai/claude-agent-sdk"
+
+import type { PlatformError } from "@effect/platform/Error"
+import { Config, Context, Data, Effect, Either, Fiber, Queue, Ref, Stream } from "effect"
+import type * as Sink from "effect/Sink"
+import { z } from "zod/v4"
+import { parseArgs } from "./parseArgs.js"
+import { decodeShimMessage } from "./schemas.js"
+
+export { parseArgs } from "./parseArgs.js"
+export type { ParsedArgs } from "./parseArgs.js"
+export { decodeShimMessage } from "./schemas.js"
+
+export class ShimError extends Data.TaggedError("ShimError")<{
+  readonly message: string
+  readonly cause: unknown
+}> {}
+
+// --- Query Service ---
+
+export type QueryParams = Parameters<typeof query>[0]
+
+export class ClaudeQuery extends Context.Tag("ClaudeQuery")<ClaudeQuery, {
+  readonly create: (params: QueryParams) => Effect.Effect<Query, ShimError>
+}>() {}
+
+// --- Config ---
+
+export const ShimConfig = Config.all({
+  realClaudePath: Config.string("REAL_CLAUDE_PATH"),
+  claudeModel: Config.withDefault(Config.string("CLAUDE_MODEL"), "claude-opus-4-6")
+})
+
+// --- IO Deps ---
+
+export interface ShimDepsService {
+  readonly args: ReadonlyArray<string>
+  readonly stdin: Stream.Stream<Uint8Array>
+  readonly stdout: Sink.Sink<void, string, never, PlatformError>
+  readonly stderr: Sink.Sink<void, string, never, PlatformError>
+}
+
+export class ShimDeps extends Context.Tag("ShimDeps")<ShimDeps, ShimDepsService>() {}
+
+const askUserQuestionSchema = {
+  questions: z.array(z.object({
+    question: z.string().describe("The question to ask the user"),
+    header: z.string().optional().describe("Short label (max 12 chars) displayed as a tag, e.g. 'Auth method'"),
+    options: z.array(z.object({
+      label: z.string().describe("Concise display text (1-5 words)"),
+      description: z.string().optional().describe("Explanation of what this option means")
+    })).min(2).max(4).describe("The available choices. Must have 2-4 options."),
+    multiSelect: z.boolean().optional().describe("Allow multiple selections")
+  }))
+}
+
+const FollowUpStop: unique symbol = Symbol.for("FollowUpStop")
+type FollowUpItem = SDKUserMessage | typeof FollowUpStop
+
+export const shimProgram = Effect.gen(function*() {
+  const deps = yield* ShimDeps
+  const queryService = yield* ClaudeQuery
+  const config = yield* ShimConfig
+  const parsed = parseArgs(deps.args)
+
+  const model = parsed.model ?? config.claudeModel
+
+  // Output queues, drained through sinks as a single stream each
+  const outQueue = yield* Queue.unbounded<string>()
+  const errQueue = yield* Queue.unbounded<string>()
+  const outFiber = yield* Stream.fromQueue(outQueue).pipe(
+    Stream.run(deps.stdout),
+    Effect.fork
+  )
+  const errFiber = yield* Stream.fromQueue(errQueue).pipe(
+    Stream.run(deps.stderr),
+    Effect.fork
+  )
+  yield* Effect.addFinalizer(() =>
+    Effect.all([Queue.shutdown(outQueue), Queue.shutdown(errQueue)]).pipe(
+      Effect.andThen(Fiber.joinAll([outFiber, errFiber]).pipe(Effect.ignore))
+    )
+  )
+  const writeStdout = (data: string) => Queue.offer(outQueue, data).pipe(Effect.asVoid)
+  const writeDebug = (msg: string) =>
+    Queue.offer(errQueue, JSON.stringify({ type: "debug", message: msg }) + "\n").pipe(Effect.asVoid)
+
+  // State refs
+  const answerQueue = yield* Queue.unbounded<string>()
+  const routingActive = yield* Ref.make(false)
+  const queryHandleRef = yield* Ref.make<{ interrupt: () => Promise<void> } | null>(null)
+  const sessionIdRef = yield* Ref.make("")
+
+  // Follow-up queue: messages or FollowUpStop to signal termination
+  const followUpQueue = yield* Queue.unbounded<FollowUpItem>()
+
+  const followUpIterable: AsyncIterable<SDKUserMessage> = Stream.fromQueue(followUpQueue).pipe(
+    Stream.takeWhile((item): item is SDKUserMessage => item !== FollowUpStop),
+    Stream.toAsyncIterable
+  )
+
+  const collectAnswers = (questionCount: number) =>
+    Stream.fromQueue(answerQueue).pipe(
+      Stream.map((line) => line.trim()),
+      Stream.filter((line) => line.length > 0),
+      Stream.take(questionCount),
+      Stream.runCollect,
+      Effect.map((chunk) => ({
+        content: [{ type: "text" as const, text: `User answered: ${Array.from(chunk).join("; ")}` }]
+      }))
+    )
+
+  const mcpServer = createSdkMcpServer({
+    name: "ask-user",
+    tools: [
+      tool(
+        "ask_user",
+        "Ask the user a question and wait for their response via Telegram. Always provide 2-4 options for the user to choose from.",
+        askUserQuestionSchema,
+        (args, _extra) => Effect.runPromise(collectAnswers(args.questions.length || 1))
+      )
+    ]
+  })
+
+  // Fork stdin reader daemon
+  yield* deps.stdin.pipe(
+    Stream.decodeText(),
+    Stream.splitLines,
+    Stream.mapEffect((line) =>
+      Effect.gen(function*() {
+        const isRouting = yield* Ref.get(routingActive)
+        if (!isRouting) {
+          yield* Queue.offer(answerQueue, line)
+          return
+        }
+
+        const decoded = decodeShimMessage(line)
+        if (Either.isLeft(decoded)) {
+          yield* Queue.offer(answerQueue, line)
+          return
+        }
+
+        const msg = decoded.right
+        const sessionId = yield* Ref.get(sessionIdRef)
+
+        switch (msg.type) {
+          case "follow_up": {
+            yield* writeDebug(`follow_up intercepted: ${msg.text.slice(0, 100)}`)
+            yield* Queue.offer(followUpQueue, {
+              type: "user",
+              message: { role: "user", content: msg.text },
+              parent_tool_use_id: null,
+              session_id: sessionId
+            })
+            return
+          }
+          case "shim_approve": {
+            yield* writeDebug("shim_approve intercepted")
+            yield* Queue.offer(followUpQueue, FollowUpStop)
+            return
+          }
+          case "shim_start": {
+            // shim_start after handshake is unexpected — ignore
+            return
+          }
+          case "shim_interrupt": {
+            yield* writeDebug("shim_interrupt intercepted")
+            const handle = yield* Ref.get(queryHandleRef)
+            if (handle !== null) {
+              yield* Effect.tryPromise({
+                try: () => handle.interrupt(),
+                catch: (err) => new ShimError({ message: "interrupt error", cause: err })
+              }).pipe(Effect.catchTag("ShimError", (err) => Effect.logError("interrupt error", err)))
+            }
+            if (msg.text != null) {
+              yield* Queue.offer(followUpQueue, {
+                type: "user",
+                message: { role: "user", content: msg.text },
+                parent_tool_use_id: null,
+                session_id: sessionId
+              })
+            }
+            return
+          }
+          case "shim_abort": {
+            yield* writeDebug("shim_abort intercepted")
+            yield* Queue.offer(followUpQueue, FollowUpStop)
+            return
+          }
+        }
+      })
+    ),
+    Stream.runDrain,
+    Effect.forkScoped
+  )
+
+  // Handshake: signal readiness and wait for control message
+  yield* writeStdout(JSON.stringify({ type: "shim_ready" }) + "\n")
+  const controlLine = yield* Queue.take(answerQueue)
+  const controlDecoded = decodeShimMessage(controlLine)
+
+  if (Either.isRight(controlDecoded) && controlDecoded.right.type === "shim_abort") return
+  if (Either.isLeft(controlDecoded) || controlDecoded.right.type !== "shim_start") {
+    return yield* new ShimError({
+      message: `Unexpected control message: ${controlLine}`,
+      cause: null
+    })
+  }
+
+  // Offer initial prompt to follow-up queue
+  yield* Queue.offer(followUpQueue, {
+    type: "user",
+    message: { role: "user", content: parsed.prompt },
+    parent_tool_use_id: null,
+    session_id: ""
+  })
+
+  const q = yield* queryService.create({
+    prompt: followUpIterable,
+    options: {
+      model,
+      pathToClaudeCodeExecutable: config.realClaudePath,
+      mcpServers: { "ask-user": mcpServer },
+      disallowedTools: ["AskUserQuestion"],
+      ...(parsed.dangerouslySkipPermissions
+        ? { permissionMode: "bypassPermissions" as const }
+        : {})
+    }
+  })
+
+  yield* Ref.set(queryHandleRef, { interrupt: () => q.interrupt() })
+  yield* Ref.set(routingActive, true)
+
+  yield* Effect.addFinalizer(() => Effect.sync(() => q.close()))
+  yield* Effect.addFinalizer(() => Queue.offer(followUpQueue, FollowUpStop))
+  yield* Effect.addFinalizer(() => Queue.shutdown(answerQueue))
+
+  yield* Stream.fromAsyncIterable(q, (err) => new ShimError({ message: "Stream error", cause: err })).pipe(
+    Stream.tap((msg: SDKMessage) =>
+      Effect.gen(function*() {
+        if (msg.type === "system" && msg.subtype === "init") {
+          yield* Ref.set(sessionIdRef, msg.session_id)
+        }
+        yield* writeStdout(JSON.stringify(msg) + "\n")
+      })
+    ),
+    Stream.runDrain
+  )
+}).pipe(Effect.scoped)

package/src/shim/parseArgs.ts

@@ -0,0 +1,43 @@
+/**
+ * CLI argument parsing for claude-shim.
+ * @since 1.0.0
+ */
+
+export interface ParsedArgs {
+  readonly prompt: string
+  readonly dangerouslySkipPermissions: boolean
+  readonly model: string | null
+}
+
+export function parseArgs(args: ReadonlyArray<string>): ParsedArgs {
+  let dangerouslySkipPermissions = false
+  let prompt = ""
+  let model: string | null = null
+  let skipNext = false
+
+  for (let i = 0; i < args.length; i++) {
+    if (skipNext) {
+      skipNext = false
+      continue
+    }
+    const arg = args[i]!
+    if (arg === "--dangerously-skip-permissions") {
+      dangerouslySkipPermissions = true
+    } else if (arg === "--output-format") {
+      skipNext = true
+    } else if (arg === "--model") {
+      model = args[i + 1] ?? null
+      skipNext = true
+    } else if (arg === "--verbose" || arg === "-p" || arg === "--print") {
+      // ignored — SDK handles output format and verbosity
+    } else if (arg === "--") {
+      // everything after -- is the prompt
+      prompt = args.slice(i + 1).join(" ")
+      break
+    } else if (!arg.startsWith("-")) {
+      prompt = arg
+    }
+  }
+
+  return { prompt, dangerouslySkipPermissions, model }
+}

package/src/shim/schemas.ts

@@ -0,0 +1,38 @@
+/**
+ * Schema definitions for claude-shim control messages.
+ * @since 1.0.0
+ */
+import { Schema } from "effect"
+
+const ShimStart = Schema.Struct({
+  type: Schema.Literal("shim_start"),
+  text: Schema.optional(Schema.String)
+})
+
+const ShimAbort = Schema.Struct({
+  type: Schema.Literal("shim_abort")
+})
+
+const ShimInterrupt = Schema.Struct({
+  type: Schema.Literal("shim_interrupt"),
+  text: Schema.optional(Schema.String)
+})
+
+const ShimApprove = Schema.Struct({
+  type: Schema.Literal("shim_approve"),
+  text: Schema.optional(Schema.String)
+})
+
+export const ShimControl = Schema.Union(ShimStart, ShimAbort, ShimInterrupt, ShimApprove)
+export type ShimControl = typeof ShimControl.Type
+
+export const FollowUp = Schema.Struct({
+  type: Schema.Literal("follow_up"),
+  text: Schema.String
+})
+export type FollowUp = typeof FollowUp.Type
+
+export const ShimMessage = Schema.Union(ShimStart, ShimAbort, ShimInterrupt, ShimApprove, FollowUp)
+export type ShimMessage = typeof ShimMessage.Type
+
+export const decodeShimMessage = Schema.decodeUnknownEither(Schema.parseJson(ShimMessage))