@interactive-inc/claude-funnel 0.8.0 → 0.8.1

package/dist/logger/leuco-human-file-writer.d.ts

@@ -0,0 +1,33 @@
+import type { LeucoHumanRecord } from "./leuco-human-record";
+import type { LeucoHumanWriter } from "./leuco-human-writer";
+type Props = {
+    /** Filesystem path. Parent directory is created on construct. */
+    path: string;
+    /**
+     * Optional size cap in bytes. When the next write would push the file
+     * over the cap, the existing file becomes `<path>.1` (replacing any
+     * prior `.1`) and a fresh file takes its place. Single-keep rotation —
+     * a second cycle drops the previous `.1`.
+     */
+    maxBytes?: number;
+};
+/**
+ * Appends one JSON line per record to a file. Optional one-keep size
+ * rotation. Designed for diagnostic logs a human tails (`tail -f file |
+ * jq`); not for replay or queries — use `LeucoLoggerSqliteSink` if you
+ * need indexed lookups.
+ *
+ * Writes are synchronous (`appendFileSync`), so each line is durable
+ * before `write` returns. Throughput matches the OS file cache; for
+ * high-volume logging consider buffering at the call site or using a
+ * different writer.
+ */
+export declare class LeucoHumanFileWriter implements LeucoHumanWriter {
+    private readonly path;
+    private readonly maxBytes;
+    constructor(props: Props);
+    write(record: LeucoHumanRecord): void | Error;
+    private ensureDir;
+    private rotateIfNeeded;
+}
+export {};

package/dist/logger/leuco-human-logger.d.ts

@@ -0,0 +1,46 @@
+import type { LeucoHumanLevel, LeucoHumanRecord } from "./leuco-human-record";
+import type { LeucoHumanWriter } from "./leuco-human-writer";
+type WriteErrorHandler = (error: Error, record: LeucoHumanRecord) => void;
+type Props = {
+    /** Where records go. Use `LeucoHumanStdoutWriter`, `LeucoHumanFileWriter`, or your own. */
+    writer: LeucoHumanWriter;
+    /** Minimum level to emit. Lower-rank records are dropped. Default: "info". */
+    level?: LeucoHumanLevel;
+    /** Override for tests. Defaults to `Date.now`. */
+    now?: () => number;
+    /** Observer for writer failures. Default: silently swallow. */
+    onWriteError?: WriteErrorHandler;
+};
+/**
+ * Human-facing diagnostic logger. The companion to `LeucoLogger`: where
+ * `LeucoLogger` is for schema-validated, replayable domain events,
+ * `LeucoHumanLogger` is for free-form info/warn/error messages destined
+ * for a human tailing a log or skimming during incident response.
+ *
+ * Keeping the two separate matters operationally:
+ *   - Diagnostics typically out-volume domain events 10–1000x; mixing
+ *     them in the same store would push events out under retention.
+ *   - Diagnostics are unstructured by design; mixing them in would defeat
+ *     the schema-first guarantee that makes domain events replayable.
+ *   - Different audiences and queries (humans grep `tail -f` vs. tools
+ *     query `WHERE seq > ?`).
+ *
+ * The writer is a port. Level gating happens here so writers receive only
+ * what is worth persisting. Failure isolation matches `LeucoLogger`: a
+ * writer that throws or returns Error is contained, surfaced via
+ * `onWriteError`, and never blocks the caller.
+ */
+export declare class LeucoHumanLogger {
+    private readonly writer;
+    private readonly minRank;
+    private readonly now;
+    private readonly onWriteError;
+    constructor(props: Props);
+    info(message: string, meta?: Record<string, unknown>): void;
+    warn(message: string, meta?: Record<string, unknown>): void;
+    error(message: string, meta?: Record<string, unknown>): void;
+    close(): void;
+    private emit;
+    private callWriter;
+}
+export {};

package/dist/logger/leuco-human-record.d.ts

@@ -0,0 +1,15 @@
+export type LeucoHumanLevel = "info" | "warn" | "error";
+/**
+ * One human-facing diagnostic log entry. Distinct from `LeucoLoggerRecord`
+ * (which wraps a schema-validated domain event) — this is the free-form,
+ * for-humans-tailing-a-log shape: a level, a message, and optional meta.
+ *
+ * `meta` is `null` rather than `undefined` when absent so writers can
+ * persist a uniform shape (no missing-key ambiguity in JSON Lines).
+ */
+export type LeucoHumanRecord = {
+    ts: number;
+    level: LeucoHumanLevel;
+    message: string;
+    meta: Record<string, unknown> | null;
+};

package/dist/logger/leuco-human-stdout-writer.d.ts

@@ -0,0 +1,20 @@
+import type { LeucoHumanRecord } from "./leuco-human-record";
+import type { LeucoHumanWriter } from "./leuco-human-writer";
+type Stream = {
+    write(s: string): void;
+};
+type Props = {
+    /** Override for tests. Defaults to `process.stdout`. */
+    out?: Stream;
+};
+/**
+ * Writes one JSON line per record to stdout. Useful as the default writer
+ * for foreground daemons, dev runs, and short-lived processes where a
+ * file-backed log would be overkill.
+ */
+export declare class LeucoHumanStdoutWriter implements LeucoHumanWriter {
+    private readonly out;
+    constructor(props?: Props);
+    write(record: LeucoHumanRecord): void;
+}
+export {};

package/dist/logger/leuco-human-writer.d.ts

@@ -0,0 +1,13 @@
+import type { LeucoHumanRecord } from "./leuco-human-record";
+/**
+ * Plugin port for `LeucoHumanLogger`. Writers decide where diagnostic
+ * records land — stdout, JSONL file, syslog, network, etc. — without the
+ * logger having to know about persistence shape.
+ *
+ * `write` returns `void` on success or an `Error` the logger surfaces via
+ * `onWriteError`. Throwing is also tolerated; the logger catches.
+ */
+export type LeucoHumanWriter = {
+    write(record: LeucoHumanRecord): void | Error;
+    close?(): void;
+};

package/dist/logger/leuco-logger-memory-sink.d.ts

@@ -0,0 +1,33 @@
+import type { LeucoLoggerRecord } from "./leuco-logger-record";
+import type { LeucoLoggerPrimarySink, LeucoLoggerSink } from "./leuco-logger-sink";
+type Props = {
+    /** Hard cap on retained records. The oldest is evicted on overflow. 0 disables retention. */
+    capacity?: number;
+};
+/**
+ * In-memory ring buffer that doubles as primary or relay. As primary it
+ * owns its own seq counter (single-process only — for multi-process
+ * safety, use `LeucoLoggerSqliteSink` as primary and place this as a
+ * relay). As relay it accepts whatever seq the primary assigned and
+ * advances its own counter to match, so `getMaxSeq` stays meaningful.
+ *
+ * Useful as a test double, as a short-window replay buffer paired with a
+ * persistent primary (covering reconnects without round-tripping disk),
+ * or as a backing store for live subscribers.
+ */
+export declare class LeucoLoggerMemorySink<E> implements LeucoLoggerPrimarySink<E>, LeucoLoggerSink<E> {
+    private readonly capacity;
+    private readonly buffer;
+    private seq;
+    constructor(props?: Props);
+    insert(input: {
+        ts: number;
+        event: E;
+    }): LeucoLoggerRecord<E>;
+    write(record: LeucoLoggerRecord<E>): void;
+    getMaxSeq(): number;
+    getRecords(): ReadonlyArray<LeucoLoggerRecord<E>>;
+    clear(): void;
+    private append;
+}
+export {};

package/dist/logger/leuco-logger-record.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Wrapper that `LeucoLogger.emit` puts around every event before handing it
+ * to a sink. `seq` is monotonic across the lifetime of the underlying store —
+ * sinks persist it as the primary key so replay (and broadcaster seeding
+ * after restart) is an indexed range scan, not a full table walk. `ts` is
+ * epoch milliseconds. `event` is the caller-defined payload validated by the
+ * Zod schema passed to the bus.
+ */
+export type LeucoLoggerRecord<E> = {
+    seq: number;
+    ts: number;
+    event: E;
+};

package/dist/logger/leuco-logger-sink.d.ts

@@ -0,0 +1,34 @@
+import type { LeucoLoggerRecord } from "./leuco-logger-record";
+/**
+ * Relay sink. Receives records that already have a `seq` assigned by the
+ * primary and stores or forwards them — memory ring, stdout, network push,
+ * a second SQLite mirror, etc. Does not generate seq itself, so any number
+ * can be attached and they all observe the same monotonic stream.
+ *
+ * `write` returns `void` on success or an `Error` the bus surfaces via
+ * `onSinkError`. Throwing is also tolerated (the bus catches), but
+ * returning is preferred so the failure path is part of the type.
+ */
+export type LeucoLoggerSink<E> = {
+    write(record: LeucoLoggerRecord<E>): void | Error;
+    close?(): void;
+};
+/**
+ * Primary sink. Owns the canonical seq sequence for the bus. `insert` is
+ * the atomic boundary — it assigns a seq strictly greater than every
+ * previously assigned one, persists the record, and returns it. SQLite
+ * implementations get atomicity for free by delegating to `INTEGER PRIMARY
+ * KEY` so two processes sharing one database file see one monotonic
+ * stream without bus-level coordination.
+ *
+ * `getMaxSeq` is the highest seq currently in the sink — used for
+ * observability and for replay seeding by clients reading the store.
+ */
+export type LeucoLoggerPrimarySink<E> = {
+    insert(input: {
+        ts: number;
+        event: E;
+    }): LeucoLoggerRecord<E> | Error;
+    getMaxSeq(): number;
+    close?(): void;
+};

package/dist/logger/leuco-logger-sqlite-sink.d.ts

@@ -0,0 +1,102 @@
+import type { LeucoLoggerRecord } from "./leuco-logger-record";
+import type { LeucoLoggerPrimarySink, LeucoLoggerSink } from "./leuco-logger-sink";
+type IndexValues<I extends ReadonlyArray<string>> = Record<I[number], string | null>;
+/**
+ * Constructor props. The shape narrows on `I`: when no indexes are
+ * declared (the default), `extractIndexes` is forbidden; when indexes
+ * are declared, both `indexes` and `extractIndexes` are required and
+ * `extractIndexes` is type-checked against the index keys.
+ */
+type Props<E, I extends ReadonlyArray<string>> = I extends readonly [] ? {
+    path: string;
+    maxRows?: number;
+    maxAgeMs?: number;
+    now?: () => number;
+    indexes?: I;
+    extractIndexes?: never;
+} : {
+    path: string;
+    maxRows?: number;
+    maxAgeMs?: number;
+    now?: () => number;
+    indexes: I;
+    extractIndexes: (event: E) => IndexValues<I>;
+};
+type GetRecordsProps<I extends ReadonlyArray<string>> = {
+    /** Return only records with seq strictly greater than this. */
+    sinceSeq?: number;
+    /** Filter by the top-level `event.type` discriminator. */
+    type?: string;
+    /** Filter by indexed columns. Keys are constrained to the declared `indexes`. */
+    where?: Partial<IndexValues<I>>;
+    /** Maximum rows returned. Default 1000. */
+    limit?: number;
+};
+/**
+ * SQLite-backed sink built on `bun:sqlite`. Implements both primary and
+ * relay roles so the same instance can own seq generation for one bus and
+ * mirror records from another (e.g. cross-process replication, restore
+ * from a backup stream).
+ *
+ * Concurrency model: seq is `INTEGER PRIMARY KEY`, so SQLite assigns it
+ * atomically via `lastInsertRowid`. Two `LeucoLogger` instances pointed
+ * at the same database file therefore see one monotonically increasing
+ * seq stream without any bus-level coordination — the database itself is
+ * the synchronization point.
+ *
+ * Schema is version-managed via `PRAGMA user_version`. Migrations are
+ * append-only and run in a transaction on every construct so a partial
+ * upgrade rolls back cleanly. Caller-defined `indexes` are layered on top
+ * via `ALTER TABLE ADD COLUMN` + `CREATE INDEX IF NOT EXISTS`, so adding
+ * a new index to an existing database is a no-downtime operation.
+ *
+ * Type safety: the second generic parameter `I` is the literal tuple of
+ * index column names. `extractIndexes` and `getRecords({ where })` are
+ * both type-checked against this tuple, so a typo at the call site is a
+ * compile-time error rather than a silent miss at runtime.
+ *
+ * Retention is bounded by `maxRows` and/or `maxAgeMs`. Both run on every
+ * insert as a single indexed DELETE that no-ops below the cap.
+ *
+ * Bulk inserts use `insertMany`, which wraps the batch in one transaction
+ * for ~10–100x throughput at the cost of one fsync per batch instead of
+ * one per row.
+ */
+export declare class LeucoLoggerSqliteSink<E, const I extends ReadonlyArray<string> = readonly []> implements LeucoLoggerPrimarySink<E>, LeucoLoggerSink<E> {
+    private readonly db;
+    private readonly maxRows;
+    private readonly maxAgeMs;
+    private readonly now;
+    private readonly indexes;
+    private readonly extractIndexes;
+    private readonly insertStmt;
+    private readonly insertWithSeqStmt;
+    private readonly maxSeqStmt;
+    private readonly countStmt;
+    private readonly trimRowsStmt;
+    private readonly trimAgeStmt;
+    constructor(props: Props<E, I>);
+    insert(input: {
+        ts: number;
+        event: E;
+    }): LeucoLoggerRecord<E> | Error;
+    insertMany(inputs: ReadonlyArray<{
+        ts: number;
+        event: E;
+    }>): LeucoLoggerRecord<E>[] | Error;
+    write(record: LeucoLoggerRecord<E>): void | Error;
+    getMaxSeq(): number;
+    getRecords(props?: GetRecordsProps<I>): LeucoLoggerRecord<E>[];
+    /**
+     * Current schema version. Useful for diagnostics and for tests that want
+     * to verify migrations ran. Reads `PRAGMA user_version` once per call.
+     */
+    getSchemaVersion(): number;
+    close(): void;
+    private buildInsertParams;
+    private appendWhereConditions;
+    private trim;
+    private syncIndexColumns;
+    private migrate;
+}
+export {};

package/dist/logger/leuco-logger.d.ts

@@ -0,0 +1,56 @@
+import type { ZodType } from "zod";
+import type { LeucoLoggerRecord } from "./leuco-logger-record";
+import type { LeucoLoggerPrimarySink, LeucoLoggerSink } from "./leuco-logger-sink";
+type Listener<E> = (record: LeucoLoggerRecord<E>) => void;
+type SinkErrorHandler<E> = (error: Error, record: LeucoLoggerRecord<E>, sink: LeucoLoggerSink<E>) => void;
+type Props<E> = {
+    /** Zod schema for the event union. Validated on every `emit`. */
+    schema: ZodType<E>;
+    /** Owns seq assignment + durability. Use `LeucoLoggerSqliteSink` for multi-process safety. */
+    primary: LeucoLoggerPrimarySink<E>;
+    /** Optional fanout for already-sequenced records (memory ring, stdout, network mirror). */
+    relays?: ReadonlyArray<LeucoLoggerSink<E>>;
+    /** Override for tests. Defaults to `Date.now`. */
+    now?: () => number;
+    /** Observer for relay failures. Default: silently swallow. */
+    onSinkError?: SinkErrorHandler<E>;
+};
+/**
+ * Schema-validated event log bus. Three responsibilities and nothing else:
+ * validate the event, delegate seq + persistence to the primary sink, and
+ * fan the resulting record out to relays and live subscribers.
+ *
+ * Splitting "primary" from "relays" makes the seq invariant honest: there
+ * is exactly one source of truth (the primary's atomic insert). Two
+ * `LeucoLogger` instances pointed at the same SQLite file therefore see
+ * one monotonic stream without bus-level coordination. Relays mirror
+ * already-sequenced records, so they can be added or removed without
+ * affecting correctness.
+ *
+ * Failure isolation:
+ *   - Primary failure short-circuits emit and is returned to the caller.
+ *   - Relay failures never block the primary path — they surface via the
+ *     optional `onSinkError` callback so the caller can observe without
+ *     being interrupted.
+ *   - A subscriber that throws is contained; the rest of the fanout
+ *     completes normally.
+ */
+export declare class LeucoLogger<E> {
+    private readonly schema;
+    private readonly primary;
+    private readonly relays;
+    private readonly now;
+    private readonly onSinkError;
+    private readonly listeners;
+    constructor(props: Props<E>);
+    emit(event: E): LeucoLoggerRecord<E> | Error;
+    subscribe(listener: Listener<E>): () => void;
+    getMaxSeq(): number;
+    close(): void;
+    private callPrimary;
+    private fanOutToRelays;
+    private callRelay;
+    private fanOutToListeners;
+    private callClose;
+}
+export {};

package/lib/index.ts

@@ -39,7 +39,9 @@ export * from "@/engine/id/memory-id-generator"
 // Connectors
 export * from "@/connectors/connector-factory"
 export * from "@/connectors/connector-config-schema"
+export * from "@/connectors/connector-listener"
 export * from "@/connectors/schedule-connector-schema"
+export * from "@/connectors/slack-connector-schema"
 
 // Gateway
 export * from "@/gateway/gateway"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@interactive-inc/claude-funnel",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "Hub CLI that routes external events (Slack / GitHub / Discord) to Claude Code agents through subscription channels over MCP.",
   "keywords": [
     "bun",
@@ -37,20 +37,25 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "bun build lib/bin.ts lib/gateway/daemon.ts --target=bun --outdir dist --minify",
+    "build": "bun run build:lib && bun run build:bin && bun run build:types && bun run build:resolve-aliases",
+    "build:lib": "bun scripts/build-lib.ts",
+    "build:bin": "bun build lib/bin.ts lib/gateway/daemon.ts --target=bun --outdir dist --minify",
+    "build:types": "tsc -p tsconfig.build.json",
+    "build:resolve-aliases": "bun scripts/resolve-d-ts-aliases.ts",
     "prepare": "bun run build"
   },
   "type": "module",
-  "main": "./lib/index.ts",
-  "module": "./lib/index.ts",
-  "types": "./lib/index.ts",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./lib/index.ts",
-      "bun": "./lib/index.ts",
-      "default": "./lib/index.ts"
+      "types": "./dist/index.d.ts",
+      "bun": "./dist/index.js",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     },
-    "./bin": "./lib/bin.ts",
+    "./bin": "./dist/bin.js",
     "./package.json": "./package.json"
   },
   "publishConfig": {