@haenah/u1z 0.1.0

package/src/conversation/messages.test.ts

@@ -0,0 +1,112 @@
+import { describe, expect, test } from "bun:test";
+import type { ModelMessage } from "ai";
+import { serializeMessage } from "./messages";
+
+const text = (messages: ModelMessage[]) => messages.flatMap(serializeMessage).join("\n");
+
+describe("serializeMessage", () => {
+  test("user/assistant/tool 메시지 전체 포함", () => {
+    const messages: ModelMessage[] = [
+      { role: "user", content: "파일 목록 보여줘" },
+      {
+        role: "assistant",
+        content: [
+          { type: "tool-call", toolCallId: "tc1", toolName: "bash", input: { command: "ls -la" } },
+        ],
+      },
+      {
+        role: "tool",
+        content: [
+          {
+            type: "tool-result",
+            toolCallId: "tc1",
+            toolName: "bash",
+            output: { type: "text", value: "file1.txt\nfile2.txt" },
+          },
+        ],
+      },
+      { role: "assistant", content: "파일 목록입니다." },
+    ];
+    expect(text(messages)).toBe(
+      "[사용자]: 파일 목록 보여줘\n" +
+        '[어시스턴트]: (tool: bash 호출)\n  입력: {"command":"ls -la"}\n' +
+        "[도구 결과 - bash]:\n  file1.txt\nfile2.txt\n" +
+        "[어시스턴트]: 파일 목록입니다.",
+    );
+  });
+
+  test("assistant에 text와 tool-call이 섞인 경우 둘 다 포함", () => {
+    const messages: ModelMessage[] = [
+      {
+        role: "assistant",
+        content: [
+          { type: "text", text: "확인해보겠습니다." },
+          { type: "tool-call", toolCallId: "1", toolName: "bash", input: { command: "pwd" } },
+        ],
+      },
+    ];
+    expect(text(messages)).toBe(
+      "[어시스턴트]: 확인해보겠습니다.\n" +
+        '[어시스턴트]: (tool: bash 호출)\n  입력: {"command":"pwd"}',
+    );
+  });
+
+  test("tool-result output - text 타입", () => {
+    const messages: ModelMessage[] = [
+      {
+        role: "tool",
+        content: [
+          {
+            type: "tool-result",
+            toolCallId: "1",
+            toolName: "bash",
+            output: { type: "text", value: "stdout 결과" },
+          },
+        ],
+      },
+    ];
+    expect(text(messages)).toBe("[도구 결과 - bash]:\n  stdout 결과");
+  });
+
+  test("tool-result output - json 타입", () => {
+    const messages: ModelMessage[] = [
+      {
+        role: "tool",
+        content: [
+          {
+            type: "tool-result",
+            toolCallId: "1",
+            toolName: "bash",
+            output: { type: "json", value: { stdout: "result", exitCode: 0 } },
+          },
+        ],
+      },
+    ];
+    expect(text(messages)).toBe('[도구 결과 - bash]:\n  {"stdout":"result","exitCode":0}');
+  });
+
+  test("tool-call만 있는 assistant 메시지도 포함", () => {
+    const messages: ModelMessage[] = [
+      {
+        role: "assistant",
+        content: [{ type: "tool-call", toolCallId: "1", toolName: "bash", input: {} }],
+      },
+      { role: "user", content: "질문" },
+    ];
+    const result = text(messages);
+    expect(result).toContain("(tool: bash 호출)");
+    expect(result).toContain("[사용자]: 질문");
+  });
+
+  test("빈 텍스트 메시지는 제외", () => {
+    const messages: ModelMessage[] = [
+      { role: "user", content: "   " },
+      { role: "assistant", content: "답변" },
+    ];
+    expect(text(messages)).toBe("[어시스턴트]: 답변");
+  });
+
+  test("메시지가 없으면 빈 문자열 반환", () => {
+    expect(text([])).toBe("");
+  });
+});

package/src/conversation/messages.ts

@@ -0,0 +1,63 @@
+import type { ModelMessage, TextPart } from "ai";
+import type { MessageRow } from "@/db/conversationStore";
+
+export type Message = ModelMessage & { createdAt: number };
+
+export function fromRow(row: MessageRow): Message {
+  return { role: row.role, content: JSON.parse(row.content), createdAt: row.created_at } as Message;
+}
+
+export function toModelMessage(msg: Message): ModelMessage {
+  return msg;
+}
+
+function serializeToolOutput(output: unknown): string {
+  const o = output as { type: string; value?: unknown; reason?: string };
+  if (o.type === "text" || o.type === "error-text") return String(o.value ?? "");
+  if (o.type === "json" || o.type === "error-json") return JSON.stringify(o.value);
+  if (o.type === "execution-denied") return `[실행 거부]${o.reason ? ` ${o.reason}` : ""}`;
+  if (o.type === "content") {
+    const parts = o.value as Array<{ type: string; text?: string }>;
+    return (
+      parts
+        .filter((p) => p.type === "text")
+        .map((p) => p.text ?? "")
+        .join("") || JSON.stringify(o.value)
+    );
+  }
+  return JSON.stringify(output);
+}
+
+export function serializeMessage(m: ModelMessage): string[] {
+  if (m.role === "user") {
+    const text =
+      typeof m.content === "string"
+        ? m.content
+        : m.content
+            .filter((p): p is TextPart => p.type === "text")
+            .map((p) => p.text)
+            .join("");
+    return text.trim() ? [`[사용자]: ${text.trim()}`] : [];
+  }
+
+  if (m.role === "assistant") {
+    if (typeof m.content === "string")
+      return m.content.trim() ? [`[어시스턴트]: ${m.content.trim()}`] : [];
+    return m.content.flatMap((part) => {
+      if (part.type === "text")
+        return part.text.trim() ? [`[어시스턴트]: ${part.text.trim()}`] : [];
+      if (part.type === "tool-call")
+        return [
+          `[어시스턴트]: (tool: ${part.toolName} 호출)\n  입력: ${JSON.stringify(part.input)}`,
+        ];
+      return [];
+    });
+  }
+
+  if (m.role === "tool")
+    return m.content
+      .filter((p) => p.type === "tool-result")
+      .map((p) => `[도구 결과 - ${p.toolName}]:\n  ${serializeToolOutput(p.output)}`);
+
+  return [];
+}

package/src/conversation/systemPrompt.ts

@@ -0,0 +1,60 @@
+import { join } from "node:path";
+import Mustache from "mustache";
+import { type MemoryData, readGlobalMemory, readMemory } from "@/memory/index";
+import type { MemoryScope } from "@/memory/types";
+
+// 프롬프트는 HTML 컨텍스트가 아니므로 HTML 이스케이프 비활성화
+Mustache.escape = (text: string) => text;
+
+function buildTemplateView(): Record<string, string> {
+  const now = new Date();
+  const formatter = new Intl.DateTimeFormat("ko-KR", {
+    timeZone: "Asia/Seoul",
+    year: "numeric",
+    month: "long",
+    day: "numeric",
+    weekday: "long",
+    hour: "2-digit",
+    minute: "2-digit",
+  });
+  return { current_time_kokr: formatter.format(now), home_dir: process.env.U1Z_HOME };
+}
+
+// 파일 캐시를 두지 않고 매번 읽는다.
+// current_time_kokr 등 동적 변수를 매 Conversation마다 최신 상태로 치환해야 하며,
+// Conversation 자체가 1시간 디바운스로 재생성되므로 호출 빈도가 낮아 I/O 부담이 없다.
+export async function getBasePrompt(): Promise<string> {
+  const path = join(process.env.U1Z_HOME, ".u1z", "prompt", "BASE.md");
+  const file = Bun.file(path);
+  if (!(await file.exists())) throw new Error(`Prompt file not found: ${path}`);
+
+  const text = (await file.text()).trim();
+  if (!text) throw new Error(`Prompt file is empty: ${path}`);
+
+  return Mustache.render(text, buildTemplateView());
+}
+
+export function buildMemoryXml(globalMemory: string, memories: MemoryData[]): string {
+  const parts: string[] = [];
+
+  if (globalMemory) parts.push(`<Shared Memory>\n${globalMemory}\n</Shared Memory>`);
+  for (const m of memories) {
+    parts.push(`<Memory at ${m.date}>\n${m.content}\n</Memory at ${m.date}>`);
+  }
+
+  if (parts.length === 0) return "";
+  return `<Memories>\n${parts.join("\n")}\n</Memories>`;
+}
+
+/** @param extra - guild 채널 발화자 포맷 설명 등 추가 컨텍스트 */
+export async function buildSystemPrompt(scope: MemoryScope, extra?: string): Promise<string> {
+  const [baseMd, globalMemory, memories] = await Promise.all([
+    getBasePrompt(),
+    readGlobalMemory(),
+    readMemory(scope),
+  ]);
+
+  const memoryXml = buildMemoryXml(globalMemory, memories);
+
+  return [baseMd, memoryXml, extra].filter(Boolean).join("\n\n---\n\n");
+}

package/src/db/conversationStore.ts

@@ -0,0 +1,100 @@
+import type { Database } from "bun:sqlite";
+
+export interface ConversationRow {
+  id: string;
+  channel_id: string;
+  scope: string;
+  model: string;
+  system_prompt: string;
+  last_message_at: number;
+  memorized: number;
+}
+
+export interface MessageRow {
+  id: number;
+  conversation_id: string;
+  role: string;
+  content: string;
+  created_at: number;
+}
+
+export interface ActiveConversationData {
+  conversation: ConversationRow;
+  messages: MessageRow[];
+}
+
+export class ConversationStore {
+  constructor(private db: Database) {}
+
+  insertConversation(
+    id: string,
+    channelId: string,
+    scope: string,
+    model: string,
+    systemPrompt: string,
+    lastMessageAt: number,
+  ): void {
+    this.db.run(
+      `INSERT INTO conversations (id, channel_id, scope, model, system_prompt, last_message_at)
+       VALUES (?, ?, ?, ?, ?, ?)`,
+      [id, channelId, scope, model, systemPrompt, lastMessageAt],
+    );
+  }
+
+  insertMessage(conversationId: string, role: string, content: string, createdAt: number): void {
+    this.db.run(
+      `INSERT INTO conversation_messages (conversation_id, role, content, created_at)
+       VALUES (?, ?, ?, ?)`,
+      [conversationId, role, content, createdAt],
+    );
+  }
+
+  touchConversation(conversationId: string, lastMessageAt: number): void {
+    this.db.run(`UPDATE conversations SET last_message_at = ? WHERE id = ?`, [
+      lastMessageAt,
+      conversationId,
+    ]);
+  }
+
+  loadActive(minLastMessageAt: number): ActiveConversationData[] {
+    const convs = this.db
+      .query<ConversationRow, [number]>(
+        `SELECT * FROM conversations WHERE memorized = 0 AND last_message_at >= ?
+         ORDER BY last_message_at ASC`,
+      )
+      .all(minLastMessageAt);
+
+    return convs.map((conv) => ({
+      conversation: conv,
+      messages: this.db
+        .query<MessageRow, [string]>(
+          `SELECT * FROM conversation_messages WHERE conversation_id = ?
+           ORDER BY id ASC`,
+        )
+        .all(conv.id),
+    }));
+  }
+
+  loadPendingMemorize(maxLastMessageAt: number): ActiveConversationData[] {
+    const convs = this.db
+      .query<ConversationRow, [number]>(
+        `SELECT * FROM conversations WHERE memorized = 0 AND last_message_at < ?
+         ORDER BY last_message_at ASC`,
+      )
+      .all(maxLastMessageAt);
+
+    return convs.map((conv) => ({
+      conversation: conv,
+      messages: this.db
+        .query<MessageRow, [string]>(
+          `SELECT * FROM conversation_messages WHERE conversation_id = ?
+           ORDER BY id ASC`,
+        )
+        .all(conv.id),
+    }));
+  }
+
+  markMemorized(conversationId: string): void {
+    this.db.run(`UPDATE conversations SET memorized = 1 WHERE id = ?`, [conversationId]);
+  }
+}

package/src/db/index.ts

@@ -0,0 +1,21 @@
+import { Database } from "bun:sqlite";
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { runMigrations as _runMigrations } from "./migrator";
+
+let _db: Database | undefined;
+
+export function getDb(): Database {
+  if (!_db) {
+    const dir = join(process.env.U1Z_HOME, ".u1z");
+    mkdirSync(dir, { recursive: true });
+    _db = new Database(join(dir, "u1z.db"), { create: true });
+    _db.run("PRAGMA journal_mode = WAL;");
+  }
+  return _db;
+}
+
+export function runMigrations(): void {
+  const migrationsDir = join(import.meta.dir, "..", "..", "migrations");
+  _runMigrations(getDb(), { migrationsDir });
+}

package/src/db/migrator.test.ts

@@ -0,0 +1,129 @@
+import { Database } from "bun:sqlite";
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { runMigrations } from "./migrator";
+
+const tempDirs: string[] = [];
+const openedDbs: Database[] = [];
+
+afterEach(() => {
+  while (openedDbs.length > 0) {
+    const db = openedDbs.pop();
+    db?.close();
+  }
+  for (const dir of tempDirs.splice(0, tempDirs.length)) {
+    rmSync(dir, { force: true, recursive: true });
+  }
+});
+
+function createTempDir(prefix: string): string {
+  const dir = mkdtempSync(join(tmpdir(), prefix));
+  tempDirs.push(dir);
+  return dir;
+}
+
+function createDb(): Database {
+  const dir = createTempDir("u1z-db-migrator-db-");
+  const db = new Database(join(dir, "app.sqlite3"), { create: true });
+  openedDbs.push(db);
+  return db;
+}
+
+function createMigrationsDir(files: Record<string, string>): string {
+  const dir = createTempDir("u1z-db-migrator-sql-");
+  mkdirSync(dir, { recursive: true });
+  for (const [filename, sql] of Object.entries(files)) {
+    writeFileSync(join(dir, filename), sql, "utf8");
+  }
+  return dir;
+}
+
+type NameRow = {
+  name: string;
+};
+
+type VersionRow = {
+  version: number;
+};
+
+describe("runMigrations", () => {
+  test("applies sql files in ascending version order", () => {
+    const db = createDb();
+    const migrationsDir = createMigrationsDir({
+      "0_init.sql": "CREATE TABLE trace (name TEXT NOT NULL);",
+      "1_insert_v1.sql": "INSERT INTO trace (name) VALUES ('v1');",
+      "2_insert_v2.sql": "INSERT INTO trace (name) VALUES ('v2');",
+    });
+
+    runMigrations(db, { migrationsDir });
+
+    const appliedVersions = db
+      .query<VersionRow, []>("SELECT version FROM schema_migrations ORDER BY version ASC")
+      .all()
+      .map((row) => row.version);
+    const traceNames = db
+      .query<NameRow, []>("SELECT name FROM trace ORDER BY rowid ASC")
+      .all()
+      .map((row) => row.name);
+
+    expect(appliedVersions).toEqual([0, 1, 2]);
+    expect(traceNames).toEqual(["v1", "v2"]);
+  });
+
+  test("applies only missing versions when new sql file is added", () => {
+    const db = createDb();
+    const migrationsDir = createMigrationsDir({
+      "0_init.sql": "CREATE TABLE trace (name TEXT NOT NULL);",
+      "1_insert_v1.sql": "INSERT INTO trace (name) VALUES ('v1');",
+    });
+
+    runMigrations(db, { migrationsDir });
+    writeFileSync(
+      join(migrationsDir, "2_insert_v2.sql"),
+      "INSERT INTO trace (name) VALUES ('v2');",
+      "utf8",
+    );
+    runMigrations(db, { migrationsDir });
+
+    const traceNames = db
+      .query<NameRow, []>("SELECT name FROM trace ORDER BY rowid ASC")
+      .all()
+      .map((row) => row.name);
+
+    expect(traceNames).toEqual(["v1", "v2"]);
+  });
+
+  test("throws when database schema version is newer than local sql files", () => {
+    const db = createDb();
+    const migrationsDir = createMigrationsDir({
+      "0_init.sql": "CREATE TABLE trace (name TEXT NOT NULL);",
+    });
+
+    runMigrations(db, { migrationsDir });
+    db.run("INSERT INTO schema_migrations (version, name) VALUES (?, ?)", [
+      99,
+      "manual_future_version",
+    ]);
+
+    expect(() => runMigrations(db, { migrationsDir })).toThrow(
+      "Database schema version 99 is newer than supported version 0",
+    );
+  });
+
+  test("supports custom migrations table name", () => {
+    const db = createDb();
+    const migrationsDir = createMigrationsDir({
+      "0_init.sql": "CREATE TABLE trace (name TEXT NOT NULL);",
+    });
+
+    runMigrations(db, { migrationsDir, migrationsTableName: "custom_migrations" });
+
+    const appliedVersions = db
+      .query<VersionRow, []>("SELECT version FROM custom_migrations ORDER BY version ASC")
+      .all()
+      .map((row) => row.version);
+    expect(appliedVersions).toEqual([0]);
+  });
+});

package/src/db/migrator.ts

@@ -0,0 +1,120 @@
+import type { Database } from "bun:sqlite";
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const MIGRATION_FILE_PATTERN = /^(\d+)_([a-zA-Z0-9_-]+)\.sql$/;
+const TABLE_NAME_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+
+type AppliedMigrationRow = {
+  version: number;
+};
+
+type MaxVersionRow = {
+  maxVersion: number | null;
+};
+
+export type SqlMigration = {
+  filename: string;
+  name: string;
+  sql: string;
+  version: number;
+};
+
+export type MigratorOptions = {
+  migrationsDir: string;
+  migrationsTableName?: string;
+};
+
+function resolveMigrationsTableName(tableName?: string): string {
+  const resolved = tableName ?? "schema_migrations";
+  if (!TABLE_NAME_PATTERN.test(resolved))
+    throw new Error(`Invalid migrations table name: ${resolved}`);
+  return resolved;
+}
+
+function loadSqlMigrations(migrationsDir: string): SqlMigration[] {
+  const entries = readdirSync(migrationsDir, { withFileTypes: true });
+  const migrations: SqlMigration[] = [];
+  const seenVersions = new Set<number>();
+
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+
+    const match = entry.name.match(MIGRATION_FILE_PATTERN);
+    if (!match) continue;
+
+    const version = Number(match[1]);
+    const name = match[2];
+    if (!Number.isInteger(version) || version < 0)
+      throw new Error(`Invalid migration version in filename: ${entry.name}`);
+    if (seenVersions.has(version)) throw new Error(`Duplicate migration version: ${version}`);
+    seenVersions.add(version);
+
+    const path = join(migrationsDir, entry.name);
+    const sql = readFileSync(path, "utf8").trim();
+    if (!sql) throw new Error(`Migration file is empty: ${entry.name}`);
+
+    migrations.push({
+      version,
+      name,
+      filename: entry.name,
+      sql,
+    });
+  }
+
+  return migrations.sort((a, b) => a.version - b.version);
+}
+
+export function runMigrations(db: Database, options: MigratorOptions): void {
+  const migrationsTableName = resolveMigrationsTableName(options.migrationsTableName);
+  const migrations = loadSqlMigrations(options.migrationsDir);
+
+  db.run(`
+    CREATE TABLE IF NOT EXISTS ${migrationsTableName} (
+      version INTEGER PRIMARY KEY,
+      name TEXT NOT NULL,
+      applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+  `);
+
+  const latestKnownVersion = migrations.at(-1)?.version ?? -1;
+  const maxVersionRow = db
+    .query<MaxVersionRow, []>(`SELECT MAX(version) AS maxVersion FROM ${migrationsTableName}`)
+    .get();
+  const maxAppliedVersion = maxVersionRow?.maxVersion ?? null;
+
+  if (maxAppliedVersion !== null && maxAppliedVersion > latestKnownVersion)
+    throw new Error(
+      `Database schema version ${maxAppliedVersion} is newer than supported version ${latestKnownVersion}`,
+    );
+
+  const appliedRows = db
+    .query<AppliedMigrationRow, []>(
+      `SELECT version FROM ${migrationsTableName} ORDER BY version ASC`,
+    )
+    .all();
+  const appliedVersions = new Set(appliedRows.map((row) => row.version));
+
+  const recordAppliedStatement = db.query<unknown, [number, string]>(`
+    INSERT INTO ${migrationsTableName} (version, name)
+    VALUES (?, ?)
+  `);
+
+  for (const migration of migrations) {
+    if (appliedVersions.has(migration.version)) continue;
+
+    db.run("BEGIN IMMEDIATE");
+    try {
+      db.run(migration.sql);
+      recordAppliedStatement.run(migration.version, migration.name);
+      db.run("COMMIT");
+      appliedVersions.add(migration.version);
+    } catch (error: unknown) {
+      db.run("ROLLBACK");
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `Failed to apply migration ${migration.filename} (v${migration.version}): ${message}`,
+      );
+    }
+  }
+}

package/src/discord/client.ts

@@ -0,0 +1,11 @@
+import { Client, GatewayIntentBits, Partials } from "discord.js";
+
+export const client = new Client({
+  intents: [
+    GatewayIntentBits.Guilds,
+    GatewayIntentBits.GuildMessages,
+    GatewayIntentBits.MessageContent,
+    GatewayIntentBits.DirectMessages,
+  ],
+  partials: [Partials.Channel],
+});

package/src/discord/handlers/interactionCreate.ts

@@ -0,0 +1,69 @@
+import {
+  AttachmentBuilder,
+  type ChatInputCommandInteraction,
+  type Interaction,
+  MessageFlags,
+} from "discord.js";
+import { conversationManager } from "@/conversation/manager";
+
+export const SLASH_COMMANDS = [
+  { name: "usage", description: "현재 대화 사용량 조회" },
+  { name: "new", description: "새 대화 시작" },
+  { name: "sysprompt", description: "현재 시스템 프롬프트 출력" },
+] as const;
+
+export async function handleInteractionCreate(interaction: Interaction): Promise<void> {
+  if (!interaction.isChatInputCommand()) return;
+
+  switch (interaction.commandName) {
+    case "usage":
+      handleUsageCommand(interaction);
+      break;
+    case "new":
+      await handleNewCommand(interaction);
+      break;
+    case "sysprompt":
+      handleSyspromptCommand(interaction);
+      break;
+    default:
+      interaction.reply({ content: "알 수 없는 명령어예요.", flags: MessageFlags.Ephemeral });
+  }
+}
+
+function handleUsageCommand(interaction: ChatInputCommandInteraction): void {
+  const conv = conversationManager.get(interaction.channelId);
+  if (!conv) {
+    interaction.reply({ content: "아직 대화가 없어요.", flags: MessageFlags.Ephemeral });
+    return;
+  }
+  interaction.reply({ content: conv.getDebugInfo(), flags: MessageFlags.Ephemeral });
+}
+
+async function handleNewCommand(interaction: ChatInputCommandInteraction): Promise<void> {
+  await interaction.deferReply();
+  const conv = conversationManager.get(interaction.channelId);
+  if (conv)
+    try {
+      await conv.memorize();
+    } catch (err) {
+      console.error(
+        "[memorize] /new 중 요약 실패:",
+        err instanceof Error ? err.message : String(err),
+      );
+    }
+  conversationManager.reset(interaction.channelId);
+  await interaction.editReply("새로운 대화를 시작했어요.");
+}
+
+async function handleSyspromptCommand(interaction: ChatInputCommandInteraction): Promise<void> {
+  const conv = conversationManager.get(interaction.channelId);
+  if (!conv) {
+    await interaction.reply({ content: "아직 대화가 없어요.", flags: MessageFlags.Ephemeral });
+    return;
+  }
+
+  const file = new AttachmentBuilder(Buffer.from(conv.systemPrompt, "utf-8"), {
+    name: "system-prompt.md",
+  });
+  await interaction.reply({ files: [file], flags: MessageFlags.Ephemeral });
+}