@interactive-inc/claude-funnel 0.7.1 → 0.8.1

package/lib/modules/connectors/funnel-discord-listener.ts

@@ -1,71 +0,0 @@
-import { Client, GatewayIntentBits, Partials } from "discord.js"
-import {
-  FunnelConnectorListener,
-  type NotifyFn,
-} from "@/modules/connectors/funnel-connector-listener"
-import { FunnelDiscordEventProcessor } from "@/modules/connectors/funnel-discord-event-processor"
-import { FunnelLogger } from "@/modules/logger/funnel-logger"
-import { NodeFunnelLogger } from "@/modules/logger/node-funnel-logger"
-import type { DiscordConnectorConfig } from "@/modules/connectors/discord-connector-schema"
-
-type Deps = {
-  config: DiscordConnectorConfig
-  logger?: FunnelLogger
-}
-
-const defaultLogger = new NodeFunnelLogger()
-
-export class FunnelDiscordListener extends FunnelConnectorListener {
-  private readonly config: DiscordConnectorConfig
-  private readonly logger: FunnelLogger
-
-  constructor(deps: Deps) {
-    super()
-    this.config = deps.config
-    this.logger = deps.logger ?? defaultLogger
-    Object.freeze(this)
-  }
-
-  async start(notify: NotifyFn): Promise<void> {
-    const client = new Client({
-      intents: [
-        GatewayIntentBits.Guilds,
-        GatewayIntentBits.GuildMessages,
-        GatewayIntentBits.MessageContent,
-        GatewayIntentBits.DirectMessages,
-      ],
-      partials: [Partials.Channel],
-    })
-
-    client.on("messageCreate", async (message) => {
-      const processor = new FunnelDiscordEventProcessor({ ownUserId: client.user?.id ?? "" })
-
-      const result = processor.process({
-        authorId: message.author.id,
-        authorIsBot: message.author.bot,
-        channelId: message.channelId,
-        guildId: message.guildId,
-        mentionedUserIds: [...message.mentions.users.keys()],
-        raw: message.toJSON(),
-      })
-
-      if (result.skip) return
-
-      try {
-        await notify(result.content, result.meta)
-      } catch (error) {
-        this.logger.error("discord notify error", {
-          error: error instanceof Error ? error.message : String(error),
-        })
-      }
-    })
-
-    client.on("error", (error) => {
-      this.logger.error("discord client error", {
-        error: error instanceof Error ? error.message : String(error),
-      })
-    })
-
-    await client.login(this.config.botToken)
-  }
-}

package/lib/modules/connectors/funnel-discord-store.ts

@@ -1,88 +0,0 @@
-import { FunnelCallableConnectorStore } from "@/modules/connectors/funnel-callable-connector-store"
-import type { FunnelConnectorAdapter } from "@/modules/connectors/funnel-connector-adapter"
-import type { FunnelConnectorListener } from "@/modules/connectors/funnel-connector-listener"
-import {
-  DEFAULT_FUNNEL_DIR,
-  FunnelJsonConnectorStore,
-} from "@/modules/connectors/funnel-json-connector-store"
-import { FunnelDiscordAdapter } from "@/modules/connectors/funnel-discord-adapter"
-import { FunnelDiscordListener } from "@/modules/connectors/funnel-discord-listener"
-import {
-  type DiscordConnectorConfig,
-  discordConnectorSchema,
-} from "@/modules/connectors/discord-connector-schema"
-import { FunnelFileSystem } from "@/modules/fs/funnel-file-system"
-import type { FunnelLogger } from "@/modules/logger/funnel-logger"
-
-type Deps = {
-  fs?: FunnelFileSystem
-  dir?: string
-  logger?: FunnelLogger
-}
-
-export type DiscordUpdateFields = {
-  botToken?: string
-}
-
-export class FunnelDiscordStore extends FunnelCallableConnectorStore<DiscordConnectorConfig> {
-  readonly type = "discord" as const
-  private readonly store: FunnelJsonConnectorStore<DiscordConnectorConfig>
-  private readonly logger?: FunnelLogger
-
-  constructor(deps: Deps = {}) {
-    super()
-    this.store = new FunnelJsonConnectorStore<DiscordConnectorConfig>({
-      type: "discord",
-      schema: discordConnectorSchema,
-      fs: deps.fs,
-      dir: deps.dir ?? DEFAULT_FUNNEL_DIR,
-    })
-    this.logger = deps.logger
-    Object.freeze(this)
-  }
-
-  list(): DiscordConnectorConfig[] {
-    return this.store.list()
-  }
-
-  get(name: string): DiscordConnectorConfig | null {
-    return this.store.get(name)
-  }
-
-  has(name: string): boolean {
-    return this.store.has(name)
-  }
-
-  add(config: DiscordConnectorConfig): void {
-    if (this.has(config.name)) throw new Error(`connector "${config.name}" already exists`)
-
-    this.store.write(config)
-  }
-
-  update(name: string, fields: DiscordUpdateFields): void {
-    const current = this.store.get(name)
-
-    if (!current) throw new Error(`connector "${name}" not found`)
-
-    this.store.write({
-      ...current,
-      botToken: fields.botToken ?? current.botToken,
-    })
-  }
-
-  remove(name: string): void {
-    this.store.remove(name)
-  }
-
-  rename(oldName: string, newName: string): void {
-    this.store.rename(oldName, newName)
-  }
-
-  createListener(config: DiscordConnectorConfig): FunnelConnectorListener {
-    return new FunnelDiscordListener({ config, logger: this.logger })
-  }
-
-  createAdapter(config: DiscordConnectorConfig): FunnelConnectorAdapter {
-    return new FunnelDiscordAdapter({ config })
-  }
-}

package/lib/modules/connectors/funnel-gh-store.ts

@@ -1,101 +0,0 @@
-import { FunnelCallableConnectorStore } from "@/modules/connectors/funnel-callable-connector-store"
-import type { FunnelConnectorAdapter } from "@/modules/connectors/funnel-connector-adapter"
-import type { FunnelConnectorListener } from "@/modules/connectors/funnel-connector-listener"
-import {
-  DEFAULT_FUNNEL_DIR,
-  FunnelJsonConnectorStore,
-} from "@/modules/connectors/funnel-json-connector-store"
-import { FunnelGhAdapter } from "@/modules/connectors/funnel-gh-adapter"
-import { FunnelGhListener } from "@/modules/connectors/funnel-gh-listener"
-import {
-  type GhConnectorConfig,
-  ghConnectorSchema,
-} from "@/modules/connectors/gh-connector-schema"
-import { FunnelFileSystem } from "@/modules/fs/funnel-file-system"
-import type { FunnelLogger } from "@/modules/logger/funnel-logger"
-import type { FunnelProcessRunner } from "@/modules/process/funnel-process-runner"
-import type { FunnelClock } from "@/modules/time/funnel-clock"
-
-type Deps = {
-  fs?: FunnelFileSystem
-  dir?: string
-  process?: FunnelProcessRunner
-  logger?: FunnelLogger
-  clock?: FunnelClock
-}
-
-export type GhUpdateFields = {
-  pollInterval?: number
-}
-
-export class FunnelGhStore extends FunnelCallableConnectorStore<GhConnectorConfig> {
-  readonly type = "gh" as const
-  private readonly store: FunnelJsonConnectorStore<GhConnectorConfig>
-  private readonly process?: FunnelProcessRunner
-  private readonly logger?: FunnelLogger
-  private readonly clock?: FunnelClock
-
-  constructor(deps: Deps = {}) {
-    super()
-    this.store = new FunnelJsonConnectorStore<GhConnectorConfig>({
-      type: "gh",
-      schema: ghConnectorSchema,
-      fs: deps.fs,
-      dir: deps.dir ?? DEFAULT_FUNNEL_DIR,
-    })
-    this.process = deps.process
-    this.logger = deps.logger
-    this.clock = deps.clock
-    Object.freeze(this)
-  }
-
-  list(): GhConnectorConfig[] {
-    return this.store.list()
-  }
-
-  get(name: string): GhConnectorConfig | null {
-    return this.store.get(name)
-  }
-
-  has(name: string): boolean {
-    return this.store.has(name)
-  }
-
-  add(config: GhConnectorConfig): void {
-    if (this.has(config.name)) throw new Error(`connector "${config.name}" already exists`)
-
-    this.store.write(config)
-  }
-
-  update(name: string, fields: GhUpdateFields): void {
-    const current = this.store.get(name)
-
-    if (!current) throw new Error(`connector "${name}" not found`)
-
-    this.store.write({
-      ...current,
-      pollInterval: fields.pollInterval ?? current.pollInterval,
-    })
-  }
-
-  remove(name: string): void {
-    this.store.remove(name)
-  }
-
-  rename(oldName: string, newName: string): void {
-    this.store.rename(oldName, newName)
-  }
-
-  createListener(config: GhConnectorConfig): FunnelConnectorListener {
-    return new FunnelGhListener({
-      config,
-      process: this.process,
-      logger: this.logger,
-      now: this.clock ? () => this.clock!.now() : undefined,
-    })
-  }
-
-  createAdapter(_config: GhConnectorConfig): FunnelConnectorAdapter {
-    return new FunnelGhAdapter()
-  }
-}

package/lib/modules/connectors/funnel-json-connector-store.ts

@@ -1,100 +0,0 @@
-import { homedir } from "node:os"
-import { join } from "node:path"
-import type { ZodType } from "zod"
-import { FunnelFileSystem } from "@/modules/fs/funnel-file-system"
-import { NodeFunnelFileSystem } from "@/modules/fs/node-funnel-file-system"
-
-const defaultFs = new NodeFunnelFileSystem()
-
-export const DEFAULT_FUNNEL_DIR = join(homedir(), ".funnel")
-
-type Props<TConfig> = {
-  type: string
-  schema: ZodType<TConfig>
-  fs?: FunnelFileSystem
-  dir?: string
-}
-
-export class FunnelJsonConnectorStore<TConfig extends { type: string; name: string }> {
-  private readonly type: string
-  private readonly schema: ZodType<TConfig>
-  private readonly fs: FunnelFileSystem
-  private readonly dir: string
-
-  constructor(props: Props<TConfig>) {
-    this.type = props.type
-    this.schema = props.schema
-    this.fs = props.fs ?? defaultFs
-    const base = props.dir ?? DEFAULT_FUNNEL_DIR
-    this.dir = join(base, "connectors", props.type)
-    Object.freeze(this)
-  }
-
-  list(): TConfig[] {
-    if (!this.fs.existsSync(this.dir)) return []
-
-    const files = this.fs.readdirSync(this.dir).filter((f) => f.endsWith(".json"))
-    const configs: TConfig[] = []
-
-    for (const file of files) {
-      const name = file.slice(0, -5)
-      const config = this.get(name)
-
-      if (config) configs.push(config)
-    }
-
-    return configs
-  }
-
-  get(name: string): TConfig | null {
-    const path = this.pathFor(name)
-
-    if (!this.fs.existsSync(path)) return null
-
-    const content = this.fs.readFileSync(path)
-    const parsed = JSON.parse(content)
-    const result = this.schema.safeParse(parsed)
-
-    if (!result.success) {
-      throw new Error(
-        `invalid ${this.type} connector "${name}": ${result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ")}`,
-      )
-    }
-
-    return result.data
-  }
-
-  has(name: string): boolean {
-    return this.fs.existsSync(this.pathFor(name))
-  }
-
-  write(config: TConfig): void {
-    this.fs.mkdirSync(this.dir, { recursive: true })
-    this.fs.writeFileSync(this.pathFor(config.name), `${JSON.stringify(config, null, 2)}\n`)
-  }
-
-  remove(name: string): void {
-    if (!this.has(name)) throw new Error(`connector "${name}" not found`)
-
-    this.fs.unlink(this.pathFor(name))
-  }
-
-  rename(oldName: string, newName: string): void {
-    const config = this.get(oldName)
-
-    if (!config) throw new Error(`connector "${oldName}" not found`)
-
-    if (this.has(newName)) {
-      throw new Error(`connector "${newName}" already exists`)
-    }
-
-    const renamed = { ...config, name: newName } as TConfig
-
-    this.write(renamed)
-    this.fs.unlink(this.pathFor(oldName))
-  }
-
-  pathFor(name: string): string {
-    return join(this.dir, `${name}.json`)
-  }
-}

package/lib/modules/connectors/funnel-schedule-listener.ts

@@ -1,130 +0,0 @@
-import {
-  FunnelConnectorListener,
-  type NotifyFn,
-} from "@/modules/connectors/funnel-connector-listener"
-import { FunnelScheduleStore } from "@/modules/connectors/funnel-schedule-store"
-import { matchCron } from "@/modules/connectors/match-cron"
-import { ScheduleLastFiredStore } from "@/modules/connectors/schedule-last-fired-store"
-import { FunnelLogger } from "@/modules/logger/funnel-logger"
-import { NodeFunnelLogger } from "@/modules/logger/node-funnel-logger"
-import type { ScheduleConnectorConfig } from "@/modules/connectors/schedule-connector-schema"
-
-type Deps = {
-  config: ScheduleConnectorConfig
-  store: FunnelScheduleStore
-  lastFiredStore: ScheduleLastFiredStore
-  logger?: FunnelLogger
-  now?: () => Date
-}
-
-const defaultLogger = new NodeFunnelLogger()
-
-const MAX_CATCHUP_MINUTES = 60 * 24
-
-export class FunnelScheduleListener extends FunnelConnectorListener {
-  private readonly config: ScheduleConnectorConfig
-  private readonly store: FunnelScheduleStore
-  private readonly lastFiredStore: ScheduleLastFiredStore
-  private readonly logger: FunnelLogger
-  private readonly now: () => Date
-
-  constructor(deps: Deps) {
-    super()
-    this.config = deps.config
-    this.store = deps.store
-    this.lastFiredStore = deps.lastFiredStore
-    this.logger = deps.logger ?? defaultLogger
-    this.now = deps.now ?? (() => new Date())
-    Object.freeze(this)
-  }
-
-  async start(notify: NotifyFn): Promise<void> {
-    const scheduleNext = () => {
-      const date = this.now()
-      const msUntilNextMinute = 60_000 - (date.getSeconds() * 1000 + date.getMilliseconds())
-      const timer = setTimeout(async () => {
-        await this.tick(notify)
-        scheduleNext()
-      }, msUntilNextMinute)
-
-      timer.unref()
-    }
-
-    await this.tick(notify)
-    scheduleNext()
-  }
-
-  async tick(notify: NotifyFn): Promise<void> {
-    const config = this.store.get(this.config.name)
-
-    if (!config) return
-
-    const now = this.truncateToMinute(this.now())
-    const state = this.lastFiredStore.load()
-    let changed = false
-
-    for (const entry of config.entries) {
-      if (!entry.enabled) continue
-
-      const lastFired = state.get(entry.id)
-      const searchFrom = lastFired ? new Date(lastFired.getTime() + 60_000) : now
-
-      if (searchFrom.getTime() > now.getTime()) continue
-
-      const match = this.findMostRecentMatch(entry.cron, searchFrom, now, entry.id)
-
-      if (!match) continue
-
-      const meta: Record<string, string> = {
-        event_type: "schedule",
-        schedule_id: entry.id,
-        cron: entry.cron,
-        fired_at: match.toISOString(),
-      }
-
-      if (match.getTime() !== now.getTime()) meta.catchup = "true"
-
-      await notify(entry.prompt, meta)
-      state.set(entry.id, match)
-      changed = true
-    }
-
-    if (changed) this.lastFiredStore.save(state)
-  }
-
-  private findMostRecentMatch(
-    cron: string,
-    from: Date,
-    until: Date,
-    entryId: string,
-  ): Date | null {
-    const maxIterations = Math.min(
-      MAX_CATCHUP_MINUTES,
-      Math.floor((until.getTime() - from.getTime()) / 60_000) + 1,
-    )
-
-    for (let i = 0; i < maxIterations; i++) {
-      const candidate = new Date(until.getTime() - i * 60_000)
-
-      try {
-        if (matchCron(cron, candidate)) return candidate
-      } catch (error) {
-        this.logger.error("invalid cron expression in schedule", {
-          connector: this.config.name,
-          id: entryId,
-          cron,
-          error: error instanceof Error ? error.message : String(error),
-        })
-        return null
-      }
-    }
-
-    return null
-  }
-
-  private truncateToMinute(date: Date): Date {
-    const copy = new Date(date.getTime())
-    copy.setSeconds(0, 0)
-    return copy
-  }
-}

package/lib/modules/connectors/funnel-schedule-store.ts

@@ -1,195 +0,0 @@
-import { join } from "node:path"
-import type { FunnelConnectorListener } from "@/modules/connectors/funnel-connector-listener"
-import { FunnelConnectorTypeStore } from "@/modules/connectors/funnel-connector-type-store"
-import { DEFAULT_FUNNEL_DIR } from "@/modules/connectors/funnel-json-connector-store"
-import { FunnelScheduleListener } from "@/modules/connectors/funnel-schedule-listener"
-import { ScheduleLastFiredStore } from "@/modules/connectors/schedule-last-fired-store"
-import {
-  type ScheduleConnectorConfig,
-  type ScheduleEntry,
-  scheduleEntrySchema,
-} from "@/modules/connectors/schedule-connector-schema"
-import { FunnelFileSystem } from "@/modules/fs/funnel-file-system"
-import { NodeFunnelFileSystem } from "@/modules/fs/node-funnel-file-system"
-import { FunnelIdGenerator } from "@/modules/id/funnel-id-generator"
-import { NodeFunnelIdGenerator } from "@/modules/id/node-funnel-id-generator"
-import { FunnelLogger } from "@/modules/logger/funnel-logger"
-import { NodeFunnelLogger } from "@/modules/logger/node-funnel-logger"
-import type { FunnelClock } from "@/modules/time/funnel-clock"
-
-type Deps = {
-  fs?: FunnelFileSystem
-  dir?: string
-  logger?: FunnelLogger
-  idGenerator?: FunnelIdGenerator
-  clock?: FunnelClock
-}
-
-const defaultFs = new NodeFunnelFileSystem()
-const defaultLogger = new NodeFunnelLogger()
-const defaultIdGenerator = new NodeFunnelIdGenerator()
-
-export class FunnelScheduleStore extends FunnelConnectorTypeStore<ScheduleConnectorConfig> {
-  readonly type = "schedule" as const
-  private readonly fs: FunnelFileSystem
-  private readonly baseDir: string
-  private readonly dir: string
-  private readonly logger: FunnelLogger
-  private readonly idGenerator: FunnelIdGenerator
-  private readonly clock?: FunnelClock
-
-  constructor(deps: Deps = {}) {
-    super()
-    this.fs = deps.fs ?? defaultFs
-    this.baseDir = deps.dir ?? DEFAULT_FUNNEL_DIR
-    this.dir = join(this.baseDir, "connectors", "schedule")
-    this.logger = deps.logger ?? defaultLogger
-    this.idGenerator = deps.idGenerator ?? defaultIdGenerator
-    this.clock = deps.clock
-    Object.freeze(this)
-  }
-
-  list(): ScheduleConnectorConfig[] {
-    if (!this.fs.existsSync(this.dir)) return []
-
-    const files = this.fs.readdirSync(this.dir).filter((f) => f.endsWith(".jsonl"))
-    const configs: ScheduleConnectorConfig[] = []
-
-    for (const file of files) {
-      const name = file.slice(0, -6)
-      const config = this.get(name)
-
-      if (config) configs.push(config)
-    }
-
-    return configs
-  }
-
-  get(name: string): ScheduleConnectorConfig | null {
-    const path = this.pathFor(name)
-
-    if (!this.fs.existsSync(path)) return null
-
-    return { type: "schedule", name, entries: this.readEntries(name) }
-  }
-
-  has(name: string): boolean {
-    return this.fs.existsSync(this.pathFor(name))
-  }
-
-  add(config: ScheduleConnectorConfig): void {
-    if (this.has(config.name)) throw new Error(`connector "${config.name}" already exists`)
-
-    this.fs.mkdirSync(this.dir, { recursive: true })
-    const lines = config.entries.map((e) => JSON.stringify(e)).join("\n")
-    this.fs.writeFileSync(this.pathFor(config.name), lines ? `${lines}\n` : "")
-  }
-
-  remove(name: string): void {
-    if (!this.has(name)) throw new Error(`connector "${name}" not found`)
-
-    this.fs.unlink(this.pathFor(name))
-    this.fs.unlink(this.statePathFor(name))
-  }
-
-  rename(oldName: string, newName: string): void {
-    if (!this.has(oldName)) throw new Error(`connector "${oldName}" not found`)
-    if (this.has(newName)) throw new Error(`connector "${newName}" already exists`)
-
-    const content = this.fs.readFileSync(this.pathFor(oldName))
-    this.fs.writeFileSync(this.pathFor(newName), content)
-    this.fs.unlink(this.pathFor(oldName))
-
-    if (this.fs.existsSync(this.statePathFor(oldName))) {
-      const state = this.fs.readFileSync(this.statePathFor(oldName))
-      this.fs.writeFileSync(this.statePathFor(newName), state)
-      this.fs.unlink(this.statePathFor(oldName))
-    }
-  }
-
-  addEntry(name: string, entry: Omit<ScheduleEntry, "id"> & { id?: string }): ScheduleEntry {
-    if (!this.has(name)) throw new Error(`connector "${name}" not found`)
-
-    const full: ScheduleEntry = {
-      id: entry.id ?? this.idGenerator.generate(),
-      cron: entry.cron,
-      prompt: entry.prompt,
-      enabled: entry.enabled ?? true,
-    }
-
-    this.fs.appendFileSync(this.pathFor(name), `${JSON.stringify(full)}\n`)
-
-    return full
-  }
-
-  removeEntry(name: string, id: string): void {
-    const entries = this.readEntries(name)
-    const next = entries.filter((e) => e.id !== id)
-
-    if (next.length === entries.length) throw new Error(`schedule entry "${id}" not found`)
-
-    const content = next.map((e) => JSON.stringify(e)).join("\n")
-    this.fs.writeFileSync(this.pathFor(name), content ? `${content}\n` : "")
-  }
-
-  createListener(config: ScheduleConnectorConfig): FunnelConnectorListener {
-    return new FunnelScheduleListener({
-      config,
-      store: this,
-      lastFiredStore: this.createLastFiredStore(config.name),
-      logger: this.logger,
-      now: this.clock ? () => this.clock!.now() : undefined,
-    })
-  }
-
-  private createLastFiredStore(name: string): ScheduleLastFiredStore {
-    return new ScheduleLastFiredStore({ connector: name, fs: this.fs, dir: this.baseDir })
-  }
-
-  private pathFor(name: string): string {
-    return join(this.dir, `${name}.jsonl`)
-  }
-
-  private statePathFor(name: string): string {
-    return join(this.dir, `${name}.state.json`)
-  }
-
-  private readEntries(name: string): ScheduleEntry[] {
-    const path = this.pathFor(name)
-
-    if (!this.fs.existsSync(path)) return []
-
-    const content = this.fs.readFileSync(path)
-    const lines = content.split("\n").filter((l) => l.trim().length > 0)
-    const entries: ScheduleEntry[] = []
-
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i]!
-      const lineNumber = i + 1
-
-      try {
-        const parsed = JSON.parse(line)
-        const result = scheduleEntrySchema.safeParse(parsed)
-
-        if (!result.success) {
-          this.logger.warn("skipping invalid schedule entry", {
-            connector: name,
-            line: lineNumber,
-            issues: result.error.issues.map((iss) => `${iss.path.join(".")}: ${iss.message}`),
-          })
-          continue
-        }
-
-        entries.push(result.data)
-      } catch (error) {
-        this.logger.warn("skipping unparseable schedule entry", {
-          connector: name,
-          line: lineNumber,
-          error: error instanceof Error ? error.message : String(error),
-        })
-      }
-    }
-
-    return entries
-  }
-}