@p-sw/brainbox 0.1.0 → 0.1.1

package/src/brain/manager.ts

@@ -1,144 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,26 +0,0 @@
-/** 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;
-}