@p-sw/brainbox 0.1.0 → 0.1.1

package/src/commands/brain.ts

@@ -1,119 +0,0 @@
-import type { Command } from "commander";
-import chalk from "chalk";
-import { registerCommand } from "@/commands";
-import { brainManager } from "@/brain/manager";
-import { Brain } from "@/brain";
-import { logger } from "@/utils/logger";
-
-export async function listBrains(): Promise<void> {
-  const brains = await brainManager.listBrains();
-  logger.debug(`listBrains: ${brains.length} brain(s)`);
-  if (brains.length === 0) {
-    logger.info("No brains found.");
-    return;
-  }
-  for (const b of brains) {
-    const status = b.activated ? chalk.green("active") : chalk.gray("inactive");
-    const channel = b.channel ? chalk.cyan(b.channel) : chalk.gray("-");
-    const name = chalk.bold(b.displayName);
-    console.log(`${b.brainId}  ${name}  ${status}  ${channel}`);
-  }
-}
-
-async function setActivated(
-  brainId: string,
-  activated: boolean,
-): Promise<void> {
-  logger.debug(`setActivated: id=${brainId} → ${activated}`);
-  const brain = await brainManager.loadBrain(brainId);
-  if (!brain) {
-    logger.error(`Brain not found: ${brainId}`);
-    process.exitCode = 1;
-    return;
-  }
-  if (brain.activated === activated) {
-    const verb = activated ? "activated" : "deactivated";
-    logger.info(`Brain "${brain.displayName}" is already ${verb}.`);
-    return;
-  }
-  await brainManager.saveBrain(brainId, { ...brain, activated });
-  const verb = activated ? "Activated" : "Deactivated";
-  logger.success(`${verb} brain "${brain.displayName}" (${brain.brainId})`);
-}
-
-export async function activateBrain(brainId: string): Promise<void> {
-  await setActivated(brainId, true);
-}
-
-export async function deactivateBrain(brainId: string): Promise<void> {
-  await setActivated(brainId, false);
-}
-
-export async function createBrain(
-  displayName: string,
-  seed: string,
-  options: { schedule: boolean },
-): Promise<void> {
-  logger.debug(
-    `createBrain: name="${displayName}" seed length=${seed.length} schedule=${options.schedule}`,
-  );
-  const result = await Brain.create(displayName, seed);
-  if (!result) {
-    process.exitCode = 1;
-    return;
-  }
-  if (options.schedule) {
-    await result.brain.regenerateSchedules();
-    logger.success(
-      `Created brain "${displayName}" (${chalk.cyan(result.brainId)}) with initial schedule`,
-    );
-  } else {
-    logger.success(
-      `Created brain "${displayName}" (${chalk.cyan(result.brainId)})`,
-    );
-  }
-}
-
-export async function removeBrain(brainId: string): Promise<void> {
-  logger.debug(`removeBrain: id=${brainId}`);
-  const brain = await brainManager.loadBrain(brainId);
-  if (!brain) {
-    logger.error(`Brain not found: ${brainId}`);
-    process.exitCode = 1;
-    return;
-  }
-  const removed = await Brain.delete(brainId);
-  if (!removed) {
-    process.exitCode = 1;
-    return;
-  }
-  logger.success(
-    `Removed brain "${brain.displayName}" (${chalk.cyan(brainId)})`,
-  );
-}
-
-export function register(program: Command): Command {
-  const cmd = registerCommand(program, {
-    name: "brain",
-    description: "Manage brains",
-  });
-  cmd.command("list").description("List all brains").action(listBrains);
-  cmd
-    .command("create <name> [seed]")
-    .description("Create a new brain from a free-form seed")
-    .option("--no-schedule", "Skip generating the initial schedule")
-    .action(createBrain);
-  cmd
-    .command("remove <brainId>")
-    .description("Remove a brain and its memory")
-    .action(removeBrain);
-  cmd
-    .command("activate <brainId>")
-    .description("Activate a brain")
-    .action(activateBrain);
-  cmd
-    .command("deactivate <brainId>")
-    .description("Deactivate a brain")
-    .action(deactivateBrain);
-  return cmd;
-}

package/src/commands/daemon/commands.ts

@@ -1,56 +0,0 @@
-// ponytail: registry for remote commands received over the daemon's unix socket.
-// Wire a command by calling defineCommand() from the command module's top level.
-
-import { logger } from "@/utils/logger";
-
-const log = logger.child("daemon-cmd");
-
-export interface CommandResult<T = unknown> {
-  ok: boolean;
-  result?: T;
-  error?: string;
-}
-
-export type CommandHandler<TArgs = unknown> = (
-  args: TArgs,
-) => Promise<CommandResult> | CommandResult;
-
-interface CommandEntry<TArgs = unknown> {
-  name: string;
-  handler: CommandHandler<TArgs>;
-}
-
-const registry = new Map<string, CommandEntry<unknown>>();
-
-export function defineCommand<TArgs>(config: {
-  name: string;
-  handler: CommandHandler<TArgs>;
-}): void {
-  log.debug(`defineCommand: registered "${config.name}"`);
-  registry.set(config.name, config as CommandEntry<unknown>);
-}
-
-export async function dispatch(payload: unknown): Promise<CommandResult> {
-  if (typeof payload !== "object" || payload === null) {
-    log.debug(`dispatch: payload not an object`);
-    return { ok: false, error: "expected object" };
-  }
-  const { command, args } = payload as { command?: unknown; args?: unknown };
-  if (typeof command !== "string" || command.length === 0) {
-    log.debug(`dispatch: missing/empty command field`);
-    return { ok: false, error: "missing command" };
-  }
-  const entry = registry.get(command);
-  if (!entry) {
-    log.debug(`dispatch: unknown command "${command}"`);
-    return { ok: false, error: `unknown command: ${command}` };
-  }
-  log.debug(`dispatch: "${command}" → handler (args type=${typeof args})`);
-  try {
-    return await entry.handler(args);
-  } catch (error) {
-    const reason = error instanceof Error ? error.message : String(error);
-    log.debug(`dispatch: "${command}" threw: ${reason}`);
-    return { ok: false, error: reason };
-  }
-}

package/src/commands/daemon/pairingCommand.ts

@@ -1,15 +0,0 @@
-import { defineCommand } from "@/commands/daemon/commands";
-import { BaseChannel } from "@/channel/base";
-import { logger } from "@/utils/logger";
-
-defineCommand<{ code: string }>({
-  name: "pairing",
-  handler: async ({ code }) => {
-    logger.debug(`pairing handler: code="${code}"`);
-    if (typeof code !== "string" || code.trim().length === 0) {
-      logger.debug(`pairing handler: missing code argument`);
-      return { ok: false, error: "missing pairing code" };
-    }
-    return await BaseChannel.completePairingByCode(code);
-  },
-});

package/src/commands/daemon/restartCommand.ts

@@ -1,17 +0,0 @@
-import { defineCommand } from "@/commands/daemon/commands";
-import { BaseChannel } from "@/channel/base";
-import { startChannels } from "@/commands/daemon";
-import { logger } from "@/utils/logger";
-
-defineCommand({
-  name: "restart",
-  handler: async () => {
-    const before = BaseChannel.all().length;
-    logger.info(`Restart: shutting down ${before} active channel(s)`);
-    logger.debug(`restart handler: tearing down ${before} active channel(s)`);
-    await BaseChannel.shutdownAll();
-    const started = await startChannels();
-    logger.success(`Restart: ${started} channel(s) back up`);
-    return { ok: true, result: { restarted: started } };
-  },
-});

package/src/commands/daemon.ts

@@ -1,168 +0,0 @@
-import type { Command } from "commander";
-import { registerCommand } from "@/commands";
-import {
-  brainManager,
-  type BrainItemDiscord,
-  type BrainItemTelegram,
-} from "@/brain/manager";
-import { Brain } from "@/brain";
-import { DiscordChannel } from "@/channel/discord";
-import { TelegramChannel } from "@/channel/telegram";
-import { logger } from "@/utils/logger";
-import { DAEMON_SOCKET_PATH } from "@/utils/daemonClient";
-import { createServer, type Socket } from "node:net";
-import { chmodSync, unlinkSync } from "node:fs";
-import { dispatch } from "./daemon/commands";
-
-import "./daemon/pairingCommand";
-import "./daemon/restartCommand";
-
-export async function startChannels(): Promise<number> {
-  const items = await brainManager.listAvailableBrain();
-  logger.debug(`startChannels: ${items.length} candidate(s)`);
-  let started = 0;
-  for (const item of items) {
-    const brain = await Brain.load(item.brainId);
-    if (!brain) {
-      logger.debug(
-        `startChannels: skip ${item.brainId} (Brain.load returned null)`,
-      );
-      continue;
-    }
-    try {
-      if (item.channel === "discord") {
-        const channel = new DiscordChannel(brain as Brain<BrainItemDiscord>);
-        await channel.init();
-        logger.success(
-          `Discord channel started: ${brain.brainbase.displayName}`,
-        );
-        started += 1;
-      } else if (item.channel === "telegram") {
-        const channel = new TelegramChannel(brain as Brain<BrainItemTelegram>);
-        await channel.init();
-        logger.success(
-          `Telegram channel started: ${brain.brainbase.displayName}`,
-        );
-        started += 1;
-      } else {
-        logger.debug(
-          `startChannels: unknown channel type "${(item as { channel: string }).channel}" for ${(item as { brainId: string }).brainId}`,
-        );
-      }
-    } catch (error) {
-      const reason = error instanceof Error ? error.message : String(error);
-      logger.error(
-        `Failed to start channel for "${brain.brainbase.displayName}" (${item.channel}): ${reason}`,
-      );
-    }
-  }
-  logger.debug(`startChannels: ${started}/${items.length} started`);
-  return started;
-}
-
-export async function daemon(): Promise<void> {
-  logger.debug(`daemon: boot`);
-  const started = await startChannels();
-  if (started === 0) {
-    logger.info("No activated brains with channels. Daemon idling.");
-  }
-  await listenOnSocket();
-}
-
-const SOCKET_PATH = DAEMON_SOCKET_PATH;
-
-async function listenOnSocket(): Promise<void> {
-  logger.debug(`listenOnSocket: unlinking stale socket at ${SOCKET_PATH}`);
-  try {
-    unlinkSync(SOCKET_PATH);
-  } catch {
-    // ponytail: stale socket from a prior crash — best-effort unlink
-  }
-
-  const sockets = new Set<Socket>();
-  const server = createServer((conn) => {
-    logger.debug(`listenOnSocket: new connection`);
-    sockets.add(conn);
-    conn.on("close", () => {
-      logger.debug(`listenOnSocket: connection closed`);
-      sockets.delete(conn);
-    });
-    handleConnection(conn);
-  });
-
-  await new Promise<void>((resolve, reject) => {
-    const onError = (err: Error) => {
-      server.off("listening", onListening);
-      reject(err);
-    };
-    const onListening = () => {
-      server.off("error", onError);
-      chmodSync(SOCKET_PATH, 0o600);
-      logger.success(`Daemon listening on unix://${SOCKET_PATH}`);
-      resolve();
-    };
-    server.once("error", onError);
-    server.once("listening", onListening);
-    server.listen(SOCKET_PATH);
-  });
-
-  await new Promise<void>((resolve) => {
-    const shutdown = () => {
-      logger.debug(`listenOnSocket: shutdown signal received`);
-      for (const s of sockets) s.destroy();
-      server.close(() => {
-        try {
-          unlinkSync(SOCKET_PATH);
-        } catch {
-          // ignore
-        }
-        resolve();
-      });
-    };
-    process.once("SIGINT", shutdown);
-    process.once("SIGTERM", shutdown);
-  });
-  logger.info("Daemon shutting down.");
-}
-
-function handleConnection(conn: Socket): void {
-  let buf = "";
-  conn.setEncoding("utf8");
-  conn.on("data", (chunk) => {
-    buf += chunk;
-    let idx: number;
-    while ((idx = buf.indexOf("\n")) >= 0) {
-      const line = buf.slice(0, idx).trim();
-      buf = buf.slice(idx + 1);
-      if (line.length === 0) continue;
-      logger.debug(`handleConnection: received line (${line.length} chars)`);
-      void handleLine(conn, line);
-    }
-  });
-  conn.on("error", (err) => {
-    logger.debug(`Socket connection error: ${err.message}`);
-  });
-}
-
-async function handleLine(conn: Socket, line: string): Promise<void> {
-  let payload: unknown;
-  try {
-    payload = JSON.parse(line);
-  } catch {
-    logger.debug(`handleLine: invalid json, replying with error`);
-    conn.write(JSON.stringify({ ok: false, error: "invalid json" }) + "\n");
-    return;
-  }
-  const cmd = (payload as { command?: string }).command;
-  logger.debug(`handleLine: dispatching command="${cmd ?? "?"}"`);
-  const response = await dispatch(payload);
-  conn.write(JSON.stringify(response) + "\n");
-}
-
-export function register(program: Command): Command {
-  return registerCommand(program, {
-    name: "daemon",
-    description:
-      "Run the BrainBox daemon (activated channels + remote commands)",
-  }).action(daemon);
-}

package/src/commands/index.ts

@@ -1,16 +0,0 @@
-import type { Command } from "commander";
-
-export interface CommandConfig {
-  name: string;
-  description: string;
-  configure?: (cmd: Command) => void;
-}
-
-export function registerCommand(
-  program: Command,
-  config: CommandConfig,
-): Command {
-  const cmd = program.command(config.name).description(config.description);
-  config.configure?.(cmd);
-  return cmd;
-}

package/src/commands/model.tsx

@@ -1,138 +0,0 @@
-import { useState } from "react";
-import { Box, Text, render } from "ink";
-import type { Command } from "commander";
-import { logger } from "@/utils/logger";
-import { TextInput } from "@/ui/TextInput";
-import { listProviderNames } from "@/provider/llm";
-import { readRootFile, setModelSlot, type ModelSlot } from "@/config/file/root";
-import { registerCommand } from "@/commands";
-
-type Slot = ModelSlot;
-
-function ModelApp({
-  slot,
-  onDone,
-}: {
-  slot: Slot;
-  onDone: () => void;
-}): React.ReactElement {
-  const root = readRootFile();
-  const current = slot === "identity" ? root.identityModel : root.conversationModel;
-  const [error, setError] = useState<string | null>(null);
-
-  return (
-    <Box flexDirection="column">
-      <Text>
-        Setting <Text color="cyan">{slot}</Text> model (current:{" "}
-        <Text dimColor>{current || "(unset)"}</Text>)
-      </Text>
-      <Text dimColor>Enter as provider/model (e.g. openai/gpt-4o)</Text>
-      <TextInput
-        prompt={`${slot}> `}
-        initialValue={current}
-        onSubmit={(raw) => {
-          const value = raw.trim();
-          if (!value) {
-            setError("Model cannot be empty");
-            return;
-          }
-          const slash = value.indexOf("/");
-          if (slash < 0) {
-            setError('Must be in "provider/model" form');
-            return;
-          }
-          const provider = value.slice(0, slash);
-          const known = listProviderNames();
-          if (!known.includes(provider)) {
-            setError(`Unknown provider "${provider}"`);
-            return;
-          }
-          setModelSlot(slot, value);
-          logger.success(`Set ${slot} model to ${value}`);
-          onDone();
-        }}
-      />
-      {error && <Text color="red">{error}</Text>}
-      <Text dimColor>
-        Known providers: {listProviderNames().slice(0, 12).join(", ")}…
-      </Text>
-    </Box>
-  );
-}
-
-function SlotPickerApp({
-  onPick,
-}: {
-  onPick: (slot: Slot) => void;
-}): React.ReactElement {
-  return (
-    <Box flexDirection="column">
-      <Text>Select which model slot to set:</Text>
-      <TextInput
-        prompt="slot [identity|conversation]> "
-        onSubmit={(v) => {
-          const s = v.trim().toLowerCase();
-          if (s !== "identity" && s !== "conversation") {
-            logger.error(`Invalid slot "${s}". Expected identity or conversation.`);
-            process.exit(1);
-          }
-          onPick(s);
-        }}
-      />
-    </Box>
-  );
-}
-
-async function runModel(slotArg?: string): Promise<void> {
-  const slot = slotArg as Slot | undefined;
-  if (slot && slot !== "identity" && slot !== "conversation") {
-    logger.error(`Invalid slot "${slot}". Expected identity or conversation.`);
-    process.exit(1);
-  }
-
-  if (slot) {
-    const app = render(<ModelApp slot={slot} onDone={() => app.unmount()} />);
-    await app.waitUntilExit();
-    return;
-  }
-
-  // ponytail: chain the two screens by re-rendering inside the same promise —
-  // one terminal render at a time keeps ink's stdin listeners sane.
-  const { promise, resolve } = Promise.withResolvers<void>();
-  let unmounted = false;
-  let active = render(
-    <SlotPickerApp
-      onPick={(picked) => {
-        active.unmount();
-        if (unmounted) return;
-        active = render(
-          <ModelApp
-            slot={picked}
-            onDone={() => {
-              active.unmount();
-              resolve();
-            }}
-          />,
-        );
-      }}
-    />,
-  );
-  void active.waitUntilExit().then(() => {
-    unmounted = true;
-    resolve();
-  });
-  await promise;
-}
-
-export function register(program: Command): Command {
-  return registerCommand(program, {
-    name: "model",
-    description: "Set identity or conversation model (interactive)",
-    configure: (cmd) =>
-      cmd
-        .argument("[slot]", "Model slot: identity or conversation")
-        .action(async (slot?: string) => {
-          await runModel(slot);
-        }),
-  });
-}