@interactive-inc/claude-funnel 0.4.1 → 0.8.0

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

@@ -1,84 +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"
-
-type Deps = {
-  fs?: FunnelFileSystem
-  dir?: string
-}
-
-export type GhUpdateFields = {
-  pollInterval?: number
-}
-
-export class FunnelGhStore extends FunnelCallableConnectorStore<GhConnectorConfig> {
-  readonly type = "gh" as const
-  private readonly store: FunnelJsonConnectorStore<GhConnectorConfig>
-
-  constructor(deps: Deps = {}) {
-    super()
-    this.store = new FunnelJsonConnectorStore<GhConnectorConfig>({
-      type: "gh",
-      schema: ghConnectorSchema,
-      fs: deps.fs,
-      dir: deps.dir ?? DEFAULT_FUNNEL_DIR,
-    })
-    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 })
-  }
-
-  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,124 +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 { logger } from "@/modules/logger"
-import type { ScheduleConnectorConfig } from "@/modules/connectors/schedule-connector-schema"
-
-type Deps = {
-  config: ScheduleConnectorConfig
-  store: FunnelScheduleStore
-  lastFiredStore: ScheduleLastFiredStore
-  now?: () => Date
-}
-
-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 now: () => Date
-
-  constructor(deps: Deps) {
-    super()
-    this.config = deps.config
-    this.store = deps.store
-    this.lastFiredStore = deps.lastFiredStore
-    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) {
-        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,178 +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 { logger } from "@/modules/logger"
-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"
-
-type Deps = {
-  fs?: FunnelFileSystem
-  dir?: string
-}
-
-const defaultFs = new NodeFunnelFileSystem()
-
-export class FunnelScheduleStore extends FunnelConnectorTypeStore<ScheduleConnectorConfig> {
-  readonly type = "schedule" as const
-  private readonly fs: FunnelFileSystem
-  private readonly baseDir: string
-  private readonly dir: string
-
-  constructor(deps: Deps = {}) {
-    super()
-    this.fs = deps.fs ?? defaultFs
-    this.baseDir = deps.dir ?? DEFAULT_FUNNEL_DIR
-    this.dir = join(this.baseDir, "connectors", "schedule")
-    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 ?? crypto.randomUUID(),
-      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),
-    })
-  }
-
-  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) {
-          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) {
-        logger.warn("skipping unparseable schedule entry", {
-          connector: name,
-          line: lineNumber,
-          error: error instanceof Error ? error.message : String(error),
-        })
-      }
-    }
-
-    return entries
-  }
-}

package/lib/modules/connectors/funnel-slack-adapter.ts

@@ -1,31 +0,0 @@
-import { WebClient } from "@slack/web-api"
-import {
-  FunnelConnectorAdapter,
-  type CallInput,
-} from "@/modules/connectors/funnel-connector-adapter"
-import type { SlackConnectorConfig } from "@/modules/connectors/slack-connector-schema"
-
-export type SlackWebClientLike = {
-  apiCall: (method: string, options: Record<string, unknown>) => Promise<unknown>
-}
-
-type Deps = {
-  config: SlackConnectorConfig
-  client?: SlackWebClientLike
-}
-
-export class FunnelSlackAdapter extends FunnelConnectorAdapter {
-  private readonly client: SlackWebClientLike
-
-  constructor(deps: Deps) {
-    super()
-    this.client = deps.client ?? new WebClient(deps.config.botToken)
-    Object.freeze(this)
-  }
-
-  async call(input: CallInput): Promise<unknown> {
-    const body = input.body && typeof input.body === "object" ? input.body : {}
-
-    return await this.client.apiCall(input.path, body as Record<string, unknown>)
-  }
-}

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

@@ -1,86 +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 { FunnelSlackAdapter } from "@/modules/connectors/funnel-slack-adapter"
-import { FunnelSlackListener } from "@/modules/connectors/funnel-slack-listener"
-import {
-  type SlackConnectorConfig,
-  slackConnectorSchema,
-} from "@/modules/connectors/slack-connector-schema"
-import { FunnelFileSystem } from "@/modules/fs/funnel-file-system"
-
-type Deps = {
-  fs?: FunnelFileSystem
-  dir?: string
-}
-
-export type SlackUpdateFields = {
-  botToken?: string
-  appToken?: string
-}
-
-export class FunnelSlackStore extends FunnelCallableConnectorStore<SlackConnectorConfig> {
-  readonly type = "slack" as const
-  private readonly store: FunnelJsonConnectorStore<SlackConnectorConfig>
-
-  constructor(deps: Deps = {}) {
-    super()
-    this.store = new FunnelJsonConnectorStore<SlackConnectorConfig>({
-      type: "slack",
-      schema: slackConnectorSchema,
-      fs: deps.fs,
-      dir: deps.dir ?? DEFAULT_FUNNEL_DIR,
-    })
-    Object.freeze(this)
-  }
-
-  list(): SlackConnectorConfig[] {
-    return this.store.list()
-  }
-
-  get(name: string): SlackConnectorConfig | null {
-    return this.store.get(name)
-  }
-
-  has(name: string): boolean {
-    return this.store.has(name)
-  }
-
-  add(config: SlackConnectorConfig): void {
-    if (this.has(config.name)) throw new Error(`connector "${config.name}" already exists`)
-
-    this.store.write(config)
-  }
-
-  update(name: string, fields: SlackUpdateFields): 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,
-      appToken: fields.appToken ?? current.appToken,
-    })
-  }
-
-  remove(name: string): void {
-    this.store.remove(name)
-  }
-
-  rename(oldName: string, newName: string): void {
-    this.store.rename(oldName, newName)
-  }
-
-  createListener(config: SlackConnectorConfig): FunnelConnectorListener {
-    return new FunnelSlackListener({ config })
-  }
-
-  createAdapter(config: SlackConnectorConfig): FunnelConnectorAdapter {
-    return new FunnelSlackAdapter({ config })
-  }
-}

package/lib/modules/connectors/migrate-legacy-connectors.ts

@@ -1,77 +0,0 @@
-import { join } from "node:path"
-import { connectorConfigSchema } from "@/modules/connectors/connector-config-schema"
-import type { ConnectorStoresBundle } from "@/modules/connectors/funnel-connector-stores"
-import { DEFAULT_FUNNEL_DIR } from "@/modules/connectors/funnel-json-connector-store"
-import { FunnelFileSystem } from "@/modules/fs/funnel-file-system"
-import { NodeFunnelFileSystem } from "@/modules/fs/node-funnel-file-system"
-import { logger } from "@/modules/logger"
-
-type Props = {
-  stores: ConnectorStoresBundle
-  fs?: FunnelFileSystem
-  dir?: string
-}
-
-const defaultFs = new NodeFunnelFileSystem()
-
-export const migrateLegacyConnectors = (props: Props): number => {
-  const fs = props.fs ?? defaultFs
-  const base = props.dir ?? DEFAULT_FUNNEL_DIR
-  const path = join(base, "settings.json")
-
-  if (!fs.existsSync(path)) return 0
-
-  const content = fs.readFileSync(path)
-  const raw = JSON.parse(content) as Record<string, unknown>
-  const legacy = raw.connectors
-
-  if (!Array.isArray(legacy) || legacy.length === 0) {
-    if (legacy !== undefined) {
-      const stripped = { ...raw }
-      delete stripped.connectors
-      fs.writeFileSync(path, `${JSON.stringify(stripped, null, 2)}\n`)
-    }
-    return 0
-  }
-
-  let migrated = 0
-
-  for (const entry of legacy) {
-    const parsed = connectorConfigSchema.safeParse(entry)
-
-    if (!parsed.success) {
-      logger.warn("skipping invalid legacy connector", {
-        error: parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", "),
-      })
-      continue
-    }
-
-    const config = parsed.data
-
-    if (config.type === "slack") {
-      if (props.stores.slack.has(config.name)) continue
-      props.stores.slack.add(config)
-    } else if (config.type === "gh") {
-      if (props.stores.gh.has(config.name)) continue
-      props.stores.gh.add(config)
-    } else if (config.type === "discord") {
-      if (props.stores.discord.has(config.name)) continue
-      props.stores.discord.add(config)
-    } else {
-      if (props.stores.schedule.has(config.name)) continue
-      props.stores.schedule.add(config)
-    }
-
-    migrated++
-  }
-
-  const stripped = { ...raw }
-  delete stripped.connectors
-  fs.writeFileSync(path, `${JSON.stringify(stripped, null, 2)}\n`)
-
-  if (migrated > 0) {
-    logger.info("migrated legacy connectors from settings.json", { count: migrated })
-  }
-
-  return migrated
-}

package/lib/modules/connectors/schedule-connector-schema.ts

@@ -1,18 +0,0 @@
-import { z } from "zod"
-
-export const scheduleEntrySchema = z.object({
-  id: z.string(),
-  cron: z.string(),
-  prompt: z.string(),
-  enabled: z.boolean().default(true),
-})
-
-export type ScheduleEntry = z.infer<typeof scheduleEntrySchema>
-
-export const scheduleConnectorSchema = z.object({
-  type: z.literal("schedule"),
-  name: z.string(),
-  entries: z.array(scheduleEntrySchema).default([]),
-})
-
-export type ScheduleConnectorConfig = z.infer<typeof scheduleConnectorSchema>