walkietalkiebot 0.3.0

package/server/db/repositories/messages.test.js

@@ -0,0 +1,152 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { resetTestDb } from "../../test/helpers.js";
+import { createConversation } from "./conversations.js";
+import {
+  getMessagesForConversation,
+  getImagesForMessage,
+  getImagesForMessages,
+  createMessage,
+  updateImageDescription,
+  deleteMessage,
+  countMessagesInConversation
+} from "./messages.js";
+beforeEach(() => {
+  resetTestDb();
+  createConversation({ id: "conv1", title: "Test Conversation" });
+});
+describe("createMessage", () => {
+  it("creates a basic message", () => {
+    const msg = createMessage({
+      id: "m1",
+      conversationId: "conv1",
+      role: "user",
+      content: "Hello"
+    });
+    expect(msg.id).toBe("m1");
+    expect(msg.role).toBe("user");
+    expect(msg.content).toBe("Hello");
+    expect(msg.position).toBe(0);
+    expect(msg.source).toBe("web");
+  });
+  it("auto-increments position", () => {
+    createMessage({ id: "m1", conversationId: "conv1", role: "user", content: "First" });
+    const m2 = createMessage({ id: "m2", conversationId: "conv1", role: "assistant", content: "Second" });
+    expect(m2.position).toBe(1);
+  });
+  it("creates message with images", () => {
+    createMessage({
+      id: "m1",
+      conversationId: "conv1",
+      role: "user",
+      content: "See this image",
+      images: [
+        { id: "img1", dataUrl: "data:image/png;base64,abc", fileName: "test.png", description: "A test image" }
+      ]
+    });
+    const images = getImagesForMessage("m1");
+    expect(images).toHaveLength(1);
+    expect(images[0].file_name).toBe("test.png");
+    expect(images[0].description).toBe("A test image");
+  });
+  it("creates message with custom source", () => {
+    const msg = createMessage({
+      id: "m1",
+      conversationId: "conv1",
+      role: "user",
+      content: "From telegram",
+      source: "telegram"
+    });
+    expect(msg.source).toBe("telegram");
+  });
+});
+describe("getMessagesForConversation", () => {
+  it("returns empty array for no messages", () => {
+    expect(getMessagesForConversation("conv1")).toEqual([]);
+  });
+  it("returns messages ordered by position", () => {
+    createMessage({ id: "m1", conversationId: "conv1", role: "user", content: "First" });
+    createMessage({ id: "m2", conversationId: "conv1", role: "assistant", content: "Second" });
+    createMessage({ id: "m3", conversationId: "conv1", role: "user", content: "Third" });
+    const msgs = getMessagesForConversation("conv1");
+    expect(msgs).toHaveLength(3);
+    expect(msgs[0].content).toBe("First");
+    expect(msgs[1].content).toBe("Second");
+    expect(msgs[2].content).toBe("Third");
+  });
+});
+describe("getImagesForMessages", () => {
+  it("returns empty map for empty input", () => {
+    const result = getImagesForMessages([]);
+    expect(result.size).toBe(0);
+  });
+  it("returns images grouped by message", () => {
+    createMessage({
+      id: "m1",
+      conversationId: "conv1",
+      role: "user",
+      content: "Image 1",
+      images: [{ id: "img1", dataUrl: "data:a", fileName: "a.png" }]
+    });
+    createMessage({
+      id: "m2",
+      conversationId: "conv1",
+      role: "user",
+      content: "Image 2",
+      images: [
+        { id: "img2", dataUrl: "data:b", fileName: "b.png" },
+        { id: "img3", dataUrl: "data:c", fileName: "c.png" }
+      ]
+    });
+    const result = getImagesForMessages(["m1", "m2"]);
+    expect(result.get("m1")).toHaveLength(1);
+    expect(result.get("m2")).toHaveLength(2);
+  });
+});
+describe("updateImageDescription", () => {
+  it("updates existing image description", () => {
+    createMessage({
+      id: "m1",
+      conversationId: "conv1",
+      role: "user",
+      content: "img",
+      images: [{ id: "img1", dataUrl: "data:a", fileName: "a.png" }]
+    });
+    expect(updateImageDescription("img1", "A nice photo")).toBe(true);
+    const images = getImagesForMessage("m1");
+    expect(images[0].description).toBe("A nice photo");
+  });
+  it("returns false for non-existing image", () => {
+    expect(updateImageDescription("nope", "desc")).toBe(false);
+  });
+});
+describe("deleteMessage", () => {
+  it("deletes existing message", () => {
+    createMessage({ id: "m1", conversationId: "conv1", role: "user", content: "Hello" });
+    expect(deleteMessage("m1")).toBe(true);
+    expect(getMessagesForConversation("conv1")).toHaveLength(0);
+  });
+  it("cascade deletes images", () => {
+    createMessage({
+      id: "m1",
+      conversationId: "conv1",
+      role: "user",
+      content: "img",
+      images: [{ id: "img1", dataUrl: "data:a", fileName: "a.png" }]
+    });
+    deleteMessage("m1");
+    expect(getImagesForMessage("m1")).toHaveLength(0);
+  });
+  it("returns false for non-existing", () => {
+    expect(deleteMessage("nope")).toBe(false);
+  });
+});
+describe("countMessagesInConversation", () => {
+  it("returns 0 for empty conversation", () => {
+    expect(countMessagesInConversation("conv1")).toBe(0);
+  });
+  it("returns correct count", () => {
+    createMessage({ id: "m1", conversationId: "conv1", role: "user", content: "a" });
+    createMessage({ id: "m2", conversationId: "conv1", role: "assistant", content: "b" });
+    expect(countMessagesInConversation("conv1")).toBe(2);
+  });
+});

package/server/db/repositories/plans.js

@@ -0,0 +1,57 @@
+import { getDb } from "../index.js";
+function listPlans(limit = 50, offset = 0) {
+  const db = getDb();
+  return db.prepare(
+    "SELECT * FROM plans ORDER BY updated_at DESC LIMIT ? OFFSET ?"
+  ).all(limit, offset);
+}
+function getPlan(id) {
+  const db = getDb();
+  return db.prepare("SELECT * FROM plans WHERE id = ?").get(id);
+}
+function createPlan(plan) {
+  const db = getDb();
+  const now = Date.now();
+  db.prepare(
+    "INSERT INTO plans (id, title, content, status, conversation_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)"
+  ).run(
+    plan.id,
+    plan.title,
+    plan.content,
+    plan.status || "draft",
+    plan.conversationId || null,
+    now,
+    now
+  );
+  return getPlan(plan.id);
+}
+function updatePlan(id, updates) {
+  const db = getDb();
+  const sets = ["updated_at = ?"];
+  const values = [Date.now()];
+  if (updates.title !== void 0) {
+    sets.push("title = ?");
+    values.push(updates.title);
+  }
+  if (updates.content !== void 0) {
+    sets.push("content = ?");
+    values.push(updates.content);
+  }
+  if (updates.status !== void 0) {
+    sets.push("status = ?");
+    values.push(updates.status);
+  }
+  values.push(id);
+  db.prepare(`UPDATE plans SET ${sets.join(", ")} WHERE id = ?`).run(...values);
+}
+function deletePlan(id) {
+  const db = getDb();
+  db.prepare("DELETE FROM plans WHERE id = ?").run(id);
+}
+export {
+  createPlan,
+  deletePlan,
+  getPlan,
+  listPlans,
+  updatePlan
+};

package/server/db/repositories/plans.test.js

@@ -0,0 +1,98 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { resetTestDb } from "../../test/helpers.js";
+import { createConversation } from "./conversations.js";
+import {
+  listPlans,
+  getPlan,
+  createPlan,
+  updatePlan,
+  deletePlan
+} from "./plans.js";
+beforeEach(() => {
+  resetTestDb();
+});
+describe("createPlan", () => {
+  it("creates a plan with default status", () => {
+    const plan = createPlan({ id: "p1", title: "My Plan", content: "# Steps\n1. Do this" });
+    expect(plan.id).toBe("p1");
+    expect(plan.title).toBe("My Plan");
+    expect(plan.content).toBe("# Steps\n1. Do this");
+    expect(plan.status).toBe("draft");
+    expect(plan.conversation_id).toBeNull();
+  });
+  it("creates a plan with custom status", () => {
+    const plan = createPlan({ id: "p1", title: "Plan", content: "x", status: "approved" });
+    expect(plan.status).toBe("approved");
+  });
+  it("creates a plan linked to a conversation", () => {
+    createConversation({ id: "c1" });
+    const plan = createPlan({ id: "p1", title: "Plan", content: "x", conversationId: "c1" });
+    expect(plan.conversation_id).toBe("c1");
+  });
+});
+describe("getPlan", () => {
+  it("returns existing plan", () => {
+    createPlan({ id: "p1", title: "Test", content: "content" });
+    const plan = getPlan("p1");
+    expect(plan).toBeDefined();
+    expect(plan.title).toBe("Test");
+  });
+  it("returns undefined for non-existing", () => {
+    expect(getPlan("nope")).toBeUndefined();
+  });
+});
+describe("listPlans", () => {
+  it("returns empty list initially", () => {
+    expect(listPlans()).toEqual([]);
+  });
+  it("returns plans ordered by updated_at DESC", () => {
+    createPlan({ id: "p1", title: "First", content: "a" });
+    createPlan({ id: "p2", title: "Second", content: "b" });
+    updatePlan("p1", { title: "First Updated" });
+    const plans = listPlans();
+    expect(plans).toHaveLength(2);
+    expect(plans[0].id).toBe("p1");
+  });
+  it("respects limit and offset", () => {
+    createPlan({ id: "p1", title: "A", content: "a" });
+    createPlan({ id: "p2", title: "B", content: "b" });
+    createPlan({ id: "p3", title: "C", content: "c" });
+    expect(listPlans(2, 0)).toHaveLength(2);
+    expect(listPlans(2, 2)).toHaveLength(1);
+  });
+});
+describe("updatePlan", () => {
+  it("updates title", () => {
+    createPlan({ id: "p1", title: "Old", content: "x" });
+    updatePlan("p1", { title: "New" });
+    expect(getPlan("p1").title).toBe("New");
+  });
+  it("updates content", () => {
+    createPlan({ id: "p1", title: "Plan", content: "old content" });
+    updatePlan("p1", { content: "new content" });
+    expect(getPlan("p1").content).toBe("new content");
+  });
+  it("updates status", () => {
+    createPlan({ id: "p1", title: "Plan", content: "x" });
+    updatePlan("p1", { status: "in_progress" });
+    expect(getPlan("p1").status).toBe("in_progress");
+  });
+  it("updates multiple fields at once", () => {
+    createPlan({ id: "p1", title: "Old", content: "old" });
+    updatePlan("p1", { title: "New", content: "new", status: "completed" });
+    const plan = getPlan("p1");
+    expect(plan.title).toBe("New");
+    expect(plan.content).toBe("new");
+    expect(plan.status).toBe("completed");
+  });
+});
+describe("deletePlan", () => {
+  it("deletes existing plan", () => {
+    createPlan({ id: "p1", title: "Plan", content: "x" });
+    deletePlan("p1");
+    expect(getPlan("p1")).toBeUndefined();
+  });
+  it("does not throw for non-existing", () => {
+    expect(() => deletePlan("nope")).not.toThrow();
+  });
+});

package/server/db/repositories/search.js

@@ -0,0 +1,34 @@
+import { getDb } from "../index.js";
+function searchMessages(query, limit = 50) {
+  if (!query.trim()) return [];
+  const db = getDb();
+  const escapedQuery = query.replace(/['"]/g, "").trim();
+  const searchTerms = escapedQuery.split(/\s+/).map((term) => `"${term}"*`).join(" ");
+  const results = db.prepare(`
+    SELECT
+      m.id as message_id,
+      m.conversation_id,
+      c.title as conversation_title,
+      m.role,
+      m.content,
+      m.timestamp,
+      snippet(messages_fts, 0, '<mark>', '</mark>', '...', 32) as snippet
+    FROM messages_fts
+    JOIN messages m ON messages_fts.rowid = m.rowid
+    JOIN conversations c ON m.conversation_id = c.id
+    WHERE messages_fts MATCH ?
+    ORDER BY rank
+    LIMIT ?
+  `).all(searchTerms, limit);
+  return results;
+}
+function rebuildSearchIndex() {
+  const db = getDb();
+  db.exec(`
+    INSERT INTO messages_fts(messages_fts) VALUES('rebuild');
+  `);
+}
+export {
+  rebuildSearchIndex,
+  searchMessages
+};

package/server/db/repositories/search.test.js

@@ -0,0 +1,61 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { resetTestDb } from "../../test/helpers.js";
+import { createConversation } from "./conversations.js";
+import { createMessage } from "./messages.js";
+import { searchMessages, rebuildSearchIndex } from "./search.js";
+beforeEach(() => {
+  resetTestDb();
+  createConversation({ id: "c1", title: "Test Conversation" });
+});
+describe("searchMessages", () => {
+  it("returns empty for empty query", () => {
+    expect(searchMessages("")).toEqual([]);
+    expect(searchMessages("  ")).toEqual([]);
+  });
+  it("finds matching messages", () => {
+    createMessage({ id: "m1", conversationId: "c1", role: "user", content: "How do I fix the authentication bug?" });
+    createMessage({ id: "m2", conversationId: "c1", role: "assistant", content: "Check your JWT token expiration." });
+    const results = searchMessages("authentication");
+    expect(results).toHaveLength(1);
+    expect(results[0].message_id).toBe("m1");
+    expect(results[0].conversation_title).toBe("Test Conversation");
+  });
+  it("finds messages with prefix matching", () => {
+    createMessage({ id: "m1", conversationId: "c1", role: "user", content: "debugging the server" });
+    const results = searchMessages("debug");
+    expect(results).toHaveLength(1);
+  });
+  it("returns multiple matches ranked", () => {
+    createMessage({ id: "m1", conversationId: "c1", role: "user", content: "react component rendering issue" });
+    createMessage({ id: "m2", conversationId: "c1", role: "assistant", content: "The react lifecycle hooks need updating" });
+    createMessage({ id: "m3", conversationId: "c1", role: "user", content: "unrelated message about python" });
+    const results = searchMessages("react");
+    expect(results).toHaveLength(2);
+  });
+  it("respects limit", () => {
+    for (let i = 0; i < 5; i++) {
+      createMessage({ id: `m${i}`, conversationId: "c1", role: "user", content: `test message ${i}` });
+    }
+    const results = searchMessages("test", 3);
+    expect(results).toHaveLength(3);
+  });
+  it("includes snippet with match markers", () => {
+    createMessage({ id: "m1", conversationId: "c1", role: "user", content: "How to configure webpack for production?" });
+    const results = searchMessages("webpack");
+    expect(results).toHaveLength(1);
+    expect(results[0].snippet).toContain("<mark>");
+  });
+  it("searches across conversations", () => {
+    createConversation({ id: "c2", title: "Second Conversation" });
+    createMessage({ id: "m1", conversationId: "c1", role: "user", content: "database migration" });
+    createMessage({ id: "m2", conversationId: "c2", role: "user", content: "database schema" });
+    const results = searchMessages("database");
+    expect(results).toHaveLength(2);
+  });
+});
+describe("rebuildSearchIndex", () => {
+  it("runs without error", () => {
+    createMessage({ id: "m1", conversationId: "c1", role: "user", content: "test" });
+    expect(() => rebuildSearchIndex()).not.toThrow();
+  });
+});

package/server/db/repositories/telegram.js

@@ -0,0 +1,30 @@
+import { getDb } from "../index.js";
+function getTelegramState(userId) {
+  const db = getDb();
+  const row = db.prepare(`
+    SELECT user_id, current_conversation_id, updated_at
+    FROM telegram_state
+    WHERE user_id = ?
+  `).get(userId);
+  return row || null;
+}
+function setTelegramConversation(userId, conversationId) {
+  const db = getDb();
+  const now = Date.now();
+  db.prepare(`
+    INSERT INTO telegram_state (user_id, current_conversation_id, updated_at)
+    VALUES (?, ?, ?)
+    ON CONFLICT(user_id) DO UPDATE SET
+      current_conversation_id = excluded.current_conversation_id,
+      updated_at = excluded.updated_at
+  `).run(userId, conversationId, now);
+}
+function clearTelegramState(userId) {
+  const db = getDb();
+  db.prepare("DELETE FROM telegram_state WHERE user_id = ?").run(userId);
+}
+export {
+  clearTelegramState,
+  getTelegramState,
+  setTelegramConversation
+};

package/server/db/schema.js

@@ -0,0 +1,165 @@
+const SCHEMA_VERSION = 4;
+function initSchema(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS schema_version (
+      version INTEGER PRIMARY KEY
+    )
+  `);
+  const row = db.prepare("SELECT version FROM schema_version ORDER BY version DESC LIMIT 1").get();
+  const currentVersion = row?.version || 0;
+  if (currentVersion < SCHEMA_VERSION) {
+    runMigrations(db, currentVersion);
+  }
+}
+function runMigrations(db, fromVersion) {
+  const migrations = [
+    migrateV1,
+    migrateV2,
+    migrateV3,
+    migrateV4
+  ];
+  for (let i = fromVersion; i < migrations.length; i++) {
+    console.log(`Running migration to version ${i + 1}...`);
+    migrations[i](db);
+    db.prepare("INSERT INTO schema_version (version) VALUES (?)").run(i + 1);
+  }
+  console.log(`Schema migrated to version ${SCHEMA_VERSION}`);
+}
+function migrateV1(db) {
+  db.exec(`
+    -- Conversations
+    CREATE TABLE conversations (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL DEFAULT 'New conversation',
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      project_id TEXT,
+      parent_id TEXT
+    );
+
+    -- Messages
+    CREATE TABLE messages (
+      id TEXT PRIMARY KEY,
+      conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+      role TEXT NOT NULL CHECK (role IN ('user', 'assistant')),
+      content TEXT NOT NULL,
+      timestamp INTEGER NOT NULL,
+      position INTEGER NOT NULL,
+      source TEXT DEFAULT 'web'
+    );
+
+    -- Message images
+    CREATE TABLE message_images (
+      id TEXT PRIMARY KEY,
+      message_id TEXT NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
+      data_url TEXT NOT NULL,
+      file_name TEXT NOT NULL,
+      description TEXT,
+      position INTEGER DEFAULT 0
+    );
+
+    -- Activities (tool usage)
+    CREATE TABLE activities (
+      id TEXT PRIMARY KEY,
+      conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+      message_id TEXT REFERENCES messages(id) ON DELETE SET NULL,
+      tool TEXT NOT NULL,
+      input TEXT,
+      status TEXT NOT NULL CHECK (status IN ('complete', 'error')),
+      timestamp INTEGER NOT NULL,
+      duration INTEGER,
+      error TEXT
+    );
+
+    -- Telegram user state
+    CREATE TABLE telegram_state (
+      user_id INTEGER PRIMARY KEY,
+      current_conversation_id TEXT REFERENCES conversations(id) ON DELETE SET NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    -- Full-text search
+    CREATE VIRTUAL TABLE messages_fts USING fts5(
+      content,
+      content='messages',
+      content_rowid='rowid'
+    );
+
+    -- Triggers to keep FTS in sync
+    CREATE TRIGGER messages_ai AFTER INSERT ON messages BEGIN
+      INSERT INTO messages_fts(rowid, content) VALUES (NEW.rowid, NEW.content);
+    END;
+
+    CREATE TRIGGER messages_ad AFTER DELETE ON messages BEGIN
+      INSERT INTO messages_fts(messages_fts, rowid, content) VALUES('delete', OLD.rowid, OLD.content);
+    END;
+
+    CREATE TRIGGER messages_au AFTER UPDATE ON messages BEGIN
+      INSERT INTO messages_fts(messages_fts, rowid, content) VALUES('delete', OLD.rowid, OLD.content);
+      INSERT INTO messages_fts(rowid, content) VALUES (NEW.rowid, NEW.content);
+    END;
+
+    -- Indexes
+    CREATE INDEX idx_conversations_updated ON conversations(updated_at DESC);
+    CREATE INDEX idx_messages_conversation ON messages(conversation_id, position);
+    CREATE INDEX idx_activities_conversation ON activities(conversation_id, timestamp DESC);
+  `);
+}
+function migrateV3(db) {
+  db.exec(`
+    -- Liner notes (artifact viewer) for conversations
+    ALTER TABLE conversations ADD COLUMN liner_notes TEXT;
+  `);
+}
+function migrateV4(db) {
+  db.exec(`
+    -- Plans (implementation plans from Claude Code plan mode)
+    CREATE TABLE plans (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      content TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'draft' CHECK (status IN ('draft', 'approved', 'in_progress', 'completed', 'archived')),
+      conversation_id TEXT REFERENCES conversations(id) ON DELETE SET NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX idx_plans_status ON plans(status);
+    CREATE INDEX idx_plans_updated ON plans(updated_at DESC);
+  `);
+}
+function migrateV2(db) {
+  db.exec(`
+    -- Background jobs
+    CREATE TABLE jobs (
+      id TEXT PRIMARY KEY,
+      conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+      prompt TEXT NOT NULL,
+      status TEXT NOT NULL CHECK (status IN ('queued', 'running', 'completed', 'failed', 'cancelled')),
+      source TEXT NOT NULL DEFAULT 'web',
+      result TEXT,
+      error TEXT,
+      pid INTEGER,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      started_at INTEGER,
+      completed_at INTEGER
+    );
+
+    -- Job event stream
+    CREATE TABLE job_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      job_id TEXT NOT NULL REFERENCES jobs(id) ON DELETE CASCADE,
+      event_type TEXT NOT NULL,
+      data TEXT,
+      timestamp INTEGER NOT NULL
+    );
+
+    CREATE INDEX idx_jobs_status ON jobs(status);
+    CREATE INDEX idx_jobs_conversation ON jobs(conversation_id);
+    CREATE INDEX idx_job_events_job ON job_events(job_id, timestamp);
+  `);
+}
+export {
+  initSchema
+};