@p-sw/brainbox 0.1.0

package/src/brain/manager.ts

@@ -0,0 +1,144 @@
+import { config } from "@/config";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { join } from "path";
+import { logger } from "@/utils/logger";
+
+const log = logger.child("brain-manager");
+
+export type ChannelKeys = "discord" | "telegram";
+export interface BrainDiscordConfig {
+  token: string;
+  channelId?: string;
+}
+export interface BrainTelegramConfig {
+  token: string;
+  chatId?: number;
+}
+export interface BrainItem {
+  brainId: string;
+  spaceName: string;
+  displayName: string;
+  baseSystemPrompt: string;
+  dndReplyProbability: number;
+  startConversationCountThreshold: number;
+  startConversationTimeThreshold: number;
+  activated: boolean;
+  channel?: ChannelKeys;
+  discord?: BrainDiscordConfig;
+  telegram?: BrainTelegramConfig;
+}
+export type BrainItemDiscord = Omit<BrainItem, "channel" | ChannelKeys> & {
+  channel: "discord";
+  discord: BrainDiscordConfig;
+};
+export type BrainItemTelegram = Omit<BrainItem, "channel" | ChannelKeys> & {
+  channel: "telegram";
+  telegram: BrainTelegramConfig;
+};
+export type BrainItemWithChannel = BrainItemDiscord | BrainItemTelegram;
+export type BrainList = BrainItem[];
+
+export class BrainDBManager {
+  constructor(private readonly root: string = config.brainboxRoot) {}
+
+  private dbFile(): string {
+    return join(this.root, "brains.json");
+  }
+
+  private async readDB(): Promise<BrainList> {
+    try {
+      const content = await readFile(this.dbFile(), { encoding: "utf-8" });
+      return JSON.parse(content) as BrainList;
+    } catch {
+      return [];
+    }
+  }
+
+  private async writeDB(list: BrainList): Promise<void> {
+    await mkdir(this.root, { recursive: true });
+    await writeFile(this.dbFile(), JSON.stringify(list, null, 2), {
+      encoding: "utf-8",
+    });
+  }
+
+  async loadBrain(brainId: string): Promise<BrainItem | undefined> {
+    log.debug(`loadBrain: id=${brainId}`);
+    const list = await this.readDB();
+    const found = list.find((b) => b.brainId === brainId);
+    log.debug(`loadBrain: ${found ? "hit" : "miss"} (db size=${list.length})`);
+    return found;
+  }
+
+  async listBrains(): Promise<BrainList> {
+    const list = await this.readDB();
+    log.debug(`listBrains: count=${list.length}`);
+    return list;
+  }
+
+  async saveBrain(brainId: string, brain: BrainItem): Promise<void> {
+    log.debug(`saveBrain: id=${brainId} name=${brain.displayName}`);
+    const list = await this.readDB();
+    const idx = list.findIndex((b) => b.brainId === brainId);
+    const op = idx >= 0 ? "update" : "insert";
+    if (idx >= 0) list[idx] = brain;
+    else list.push(brain);
+    await this.writeDB(list);
+    log.debug(`saveBrain: ${op} committed (db size=${list.length})`);
+  }
+
+  async listAvailableBrain(): Promise<BrainItemWithChannel[]> {
+    const list = await this.readDB();
+    const ready = list.filter((b) => this.isBrainReady(b));
+    log.debug(
+      `listAvailableBrain: ${ready.length}/${list.length} ready (channel-bound + activated)`,
+    );
+    return ready;
+  }
+
+  async deleteBrain(brainId: string): Promise<void> {
+    log.debug(`deleteBrain: id=${brainId}`);
+    const list = await this.readDB();
+    const filtered = list.filter((b) => b.brainId !== brainId);
+    if (filtered.length === list.length) {
+      log.debug(`deleteBrain: no-op (id not in db)`);
+      return;
+    }
+    await this.writeDB(filtered);
+    log.debug(`deleteBrain: removed (db size=${filtered.length})`);
+  }
+
+  async isBrainAvailable(brainId: string): Promise<boolean> {
+    const item = await this.loadBrain(brainId);
+    const ok = item !== undefined && this.isBrainReady(item);
+    log.debug(`isBrainAvailable: id=${brainId} → ${ok}`);
+    return ok;
+  }
+
+  isBrainReady(item: BrainItem): item is BrainItemWithChannel {
+    if (!item.activated) {
+      log.debug(`isBrainReady: ${item.brainId} not activated`);
+      return false;
+    }
+    switch (item.channel) {
+      case "discord":
+        if (!item.discord?.token) {
+          log.debug(`isBrainReady: ${item.brainId} missing discord.token`);
+          return false;
+        }
+        return true;
+      case "telegram":
+        if (!item.telegram?.token) {
+          log.debug(`isBrainReady: ${item.brainId} missing telegram.token`);
+          return false;
+        }
+        return true;
+      default:
+        log.debug(
+          `isBrainReady: ${item.brainId} has no channel configured`,
+        );
+        return false;
+    }
+  }
+}
+
+export const brainManager = new BrainDBManager();

package/src/brain/memory.ts

@@ -0,0 +1,99 @@
+import type Supermemory from "supermemory";
+import { logger } from "@/utils/logger";
+import type { FactInput, FactMetadata, SearchHit, Space } from "./types";
+
+const log = logger.child("memory");
+
+export class Memory {
+  constructor(
+    public db: Supermemory,
+    public space: Space,
+  ) {
+    log.debug(`Memory constructed for space=${space.name}`);
+  }
+
+  // ---------------------------------------------------------------------------
+  // Memory primitives — thin wrappers over supermemory's `documents` API.
+  //
+  //   containerTag = space.name
+  //   customId     = the stable lookup key (e.g. "daily-schedule:2026-06-10")
+  //   content      = the fact text or JSON-encoded schedule
+  //   metadata     = filterable bag: { kind, source, ... }
+  // ---------------------------------------------------------------------------
+
+  async add(input: FactInput): Promise<{ id: string }> {
+    log.debug(
+      `add: customId=${input.customId} kind=${input.metadata?.["kind"] ?? "-"} bytes=${input.content.length}`,
+    );
+    const response = await this.db.documents.add({
+      content: input.content,
+      containerTag: this.space.name,
+      customId: input.customId,
+      metadata: input.metadata,
+    });
+    log.debug(`add: stored id=${response.id}`);
+    return { id: response.id };
+  }
+
+  async get(
+    customId: string,
+  ): Promise<{ content: string; metadata: FactMetadata | null } | null> {
+    log.debug(`get: customId=${customId}`);
+    const listed = await this.db.documents.list({
+      containerTags: [this.space.name],
+      limit: 200,
+    });
+    const match = (listed.memories ?? []).find((m) => m.customId === customId);
+    if (!match) {
+      log.debug(`get: miss for customId=${customId}`);
+      return null;
+    }
+    const full = await this.db.documents.get(match.id);
+    log.debug(`get: hit customId=${customId} bytes=${full.content?.length ?? 0}`);
+    return {
+      content: full.content ?? "",
+      metadata: (full.metadata ?? null) as FactMetadata | null,
+    };
+  }
+
+  async clear(): Promise<void> {
+    log.debug(`clear: deleting all docs in space=${this.space.name}`);
+    await this.db.documents.deleteBulk({ containerTags: [this.space.name] });
+    log.debug(`clear: done`);
+  }
+
+  async list(): Promise<Array<{ customId: string | null; content: string }>> {
+    log.debug(`list: fetching up to 200 docs in space=${this.space.name}`);
+    const listed = await this.db.documents.list({
+      containerTags: [this.space.name],
+      limit: 200,
+    });
+    const docs = (listed.memories ?? []).map((d) => ({
+      customId: d.customId,
+      content: d.content ?? "",
+    }));
+    log.debug(`list: got ${docs.length} docs`);
+    return docs;
+  }
+
+  async search(query: string, limit = 5): Promise<SearchHit[]> {
+    log.debug(
+      `search: q="${query}" limit=${limit} space=${this.space.name}`,
+    );
+    const response = await this.db.search.execute({
+      q: query,
+      containerTag: this.space.name,
+      limit,
+      onlyMatchingChunks: true,
+    });
+    const hits = (response.results ?? []).map((r) => {
+      const firstChunk = r.chunks?.[0];
+      return {
+        content: firstChunk?.content ?? "",
+        score: r.score,
+      };
+    });
+    log.debug(`search: ${hits.length} hits`);
+    return hits;
+  }
+}

package/src/brain/messageHistory.ts

@@ -0,0 +1,26 @@
+export type MessageSender = "persona" | "user";
+
+export interface MessageHistoryEntry {
+  sender: MessageSender;
+  time: Date;
+  content: string;
+}
+
+function formatTime(time: Date): string {
+  const pad = (n: number) => n.toString().padStart(2, "0");
+  return `${time.getFullYear()}-${pad(time.getMonth() + 1)}-${pad(
+    time.getDate(),
+  )} ${pad(time.getHours())}:${pad(time.getMinutes())}:${pad(time.getSeconds())}`;
+}
+
+export function translateMessageHistory(
+  personaName: string,
+  entries: ReadonlyArray<MessageHistoryEntry>,
+): string {
+  return entries
+    .map((entry) => {
+      const label = entry.sender === "persona" ? personaName : "사용자";
+      return `${label}@${formatTime(entry.time)}: ${entry.content}`;
+    })
+    .join("\n");
+}

package/src/brain/schedule.ts

@@ -0,0 +1,11 @@
+export function pad2(n: number): string {
+  return n < 10 ? `0${n}` : `${n}`;
+}
+
+export function formatDateKey(d: Date): string {
+  return `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())}`;
+}
+
+export function formatMonthKey(d: Date): string {
+  return `${d.getFullYear()}-${pad2(d.getMonth() + 1)}`;
+}

package/src/brain/types.ts

@@ -0,0 +1,26 @@
+/** A brain's logical namespace. Maps to supermemory's `containerTag`. */
+export interface Space {
+  name: string;
+  description?: string;
+}
+
+/** Metadata bag stored alongside a document in supermemory. */
+export type FactMetadata = Record<string, string | number | boolean | string[]>;
+
+/**
+ * A fact/document to store in the brain's memory. Mirrors supermemory's
+ * `documents.add` parameter shape: `content` is the canonical text (or
+ * JSON-encoded schedule), `customId` is the stable lookup key, and
+ * `metadata` is the filterable bag.
+ */
+export interface FactInput {
+  customId: string;
+  content: string;
+  metadata?: FactMetadata;
+}
+
+/** A single semantic-search hit. */
+export interface SearchHit {
+  content: string;
+  score: number;
+}