walkietalkiebot 0.3.0

package/server/db/repositories/activities.js

@@ -0,0 +1,85 @@
+import { getDb } from "../index.js";
+function getActivitiesForConversation(conversationId, limit = 100) {
+  const db = getDb();
+  return db.prepare(`
+    SELECT id, conversation_id, message_id, tool, input, status, timestamp, duration, error
+    FROM activities
+    WHERE conversation_id = ?
+    ORDER BY timestamp DESC
+    LIMIT ?
+  `).all(conversationId, limit);
+}
+function getActivitiesForMessage(messageId) {
+  const db = getDb();
+  return db.prepare(`
+    SELECT id, conversation_id, message_id, tool, input, status, timestamp, duration, error
+    FROM activities
+    WHERE message_id = ?
+    ORDER BY timestamp ASC
+  `).all(messageId);
+}
+function createActivity(input) {
+  const db = getDb();
+  const timestamp = input.timestamp || Date.now();
+  db.prepare(`
+    INSERT INTO activities (id, conversation_id, message_id, tool, input, status, timestamp, duration, error)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    input.id,
+    input.conversationId,
+    input.messageId || null,
+    input.tool,
+    input.input || null,
+    input.status,
+    timestamp,
+    input.duration || null,
+    input.error || null
+  );
+  return {
+    id: input.id,
+    conversation_id: input.conversationId,
+    message_id: input.messageId || null,
+    tool: input.tool,
+    input: input.input || null,
+    status: input.status,
+    timestamp,
+    duration: input.duration || null,
+    error: input.error || null
+  };
+}
+function createActivitiesBatch(activities) {
+  if (activities.length === 0) return;
+  const db = getDb();
+  const insert = db.prepare(`
+    INSERT INTO activities (id, conversation_id, message_id, tool, input, status, timestamp, duration, error)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  const insertMany = db.transaction((items) => {
+    for (const input of items) {
+      insert.run(
+        input.id,
+        input.conversationId,
+        input.messageId || null,
+        input.tool,
+        input.input || null,
+        input.status,
+        input.timestamp || Date.now(),
+        input.duration || null,
+        input.error || null
+      );
+    }
+  });
+  insertMany(activities);
+}
+function deleteActivitiesForConversation(conversationId) {
+  const db = getDb();
+  const result = db.prepare("DELETE FROM activities WHERE conversation_id = ?").run(conversationId);
+  return result.changes;
+}
+export {
+  createActivitiesBatch,
+  createActivity,
+  deleteActivitiesForConversation,
+  getActivitiesForConversation,
+  getActivitiesForMessage
+};

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

@@ -0,0 +1,106 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { resetTestDb } from "../../test/helpers.js";
+import { createConversation } from "./conversations.js";
+import { createMessage } from "./messages.js";
+import {
+  getActivitiesForConversation,
+  getActivitiesForMessage,
+  createActivity,
+  createActivitiesBatch,
+  deleteActivitiesForConversation
+} from "./activities.js";
+beforeEach(() => {
+  resetTestDb();
+  createConversation({ id: "c1", title: "Test" });
+});
+describe("createActivity", () => {
+  it("creates a basic activity", () => {
+    const activity = createActivity({
+      id: "a1",
+      conversationId: "c1",
+      tool: "Read",
+      status: "complete"
+    });
+    expect(activity.id).toBe("a1");
+    expect(activity.tool).toBe("Read");
+    expect(activity.status).toBe("complete");
+    expect(activity.message_id).toBeNull();
+    expect(activity.input).toBeNull();
+    expect(activity.duration).toBeNull();
+    expect(activity.error).toBeNull();
+  });
+  it("creates activity with all optional fields", () => {
+    createMessage({ id: "m1", conversationId: "c1", role: "user", content: "test" });
+    const activity = createActivity({
+      id: "a1",
+      conversationId: "c1",
+      messageId: "m1",
+      tool: "Bash",
+      input: "npm run test",
+      status: "error",
+      duration: 1500,
+      error: "Exit code 1"
+    });
+    expect(activity.message_id).toBe("m1");
+    expect(activity.input).toBe("npm run test");
+    expect(activity.status).toBe("error");
+    expect(activity.duration).toBe(1500);
+    expect(activity.error).toBe("Exit code 1");
+  });
+});
+describe("getActivitiesForConversation", () => {
+  it("returns empty for no activities", () => {
+    expect(getActivitiesForConversation("c1")).toEqual([]);
+  });
+  it("returns activities ordered by timestamp DESC", () => {
+    createActivity({ id: "a1", conversationId: "c1", tool: "Read", status: "complete", timestamp: 1e3 });
+    createActivity({ id: "a2", conversationId: "c1", tool: "Edit", status: "complete", timestamp: 2e3 });
+    createActivity({ id: "a3", conversationId: "c1", tool: "Bash", status: "complete", timestamp: 3e3 });
+    const activities = getActivitiesForConversation("c1");
+    expect(activities).toHaveLength(3);
+    expect(activities[0].tool).toBe("Bash");
+    expect(activities[2].tool).toBe("Read");
+  });
+  it("respects limit", () => {
+    for (let i = 0; i < 5; i++) {
+      createActivity({ id: `a${i}`, conversationId: "c1", tool: "Read", status: "complete", timestamp: i });
+    }
+    expect(getActivitiesForConversation("c1", 3)).toHaveLength(3);
+  });
+});
+describe("getActivitiesForMessage", () => {
+  it("returns activities for a specific message", () => {
+    createMessage({ id: "m1", conversationId: "c1", role: "user", content: "test" });
+    createActivity({ id: "a1", conversationId: "c1", messageId: "m1", tool: "Read", status: "complete" });
+    createActivity({ id: "a2", conversationId: "c1", messageId: "m1", tool: "Edit", status: "complete" });
+    createActivity({ id: "a3", conversationId: "c1", tool: "Bash", status: "complete" });
+    const activities = getActivitiesForMessage("m1");
+    expect(activities).toHaveLength(2);
+  });
+});
+describe("createActivitiesBatch", () => {
+  it("handles empty array", () => {
+    expect(() => createActivitiesBatch([])).not.toThrow();
+    expect(getActivitiesForConversation("c1")).toHaveLength(0);
+  });
+  it("inserts multiple activities in one transaction", () => {
+    createActivitiesBatch([
+      { id: "a1", conversationId: "c1", tool: "Read", status: "complete" },
+      { id: "a2", conversationId: "c1", tool: "Edit", status: "complete" },
+      { id: "a3", conversationId: "c1", tool: "Bash", status: "error", error: "fail" }
+    ]);
+    expect(getActivitiesForConversation("c1")).toHaveLength(3);
+  });
+});
+describe("deleteActivitiesForConversation", () => {
+  it("deletes all activities for a conversation", () => {
+    createActivity({ id: "a1", conversationId: "c1", tool: "Read", status: "complete" });
+    createActivity({ id: "a2", conversationId: "c1", tool: "Edit", status: "complete" });
+    const deleted = deleteActivitiesForConversation("c1");
+    expect(deleted).toBe(2);
+    expect(getActivitiesForConversation("c1")).toHaveLength(0);
+  });
+  it("returns 0 when no activities exist", () => {
+    expect(deleteActivitiesForConversation("c1")).toBe(0);
+  });
+});

package/server/db/repositories/conversations.js

@@ -0,0 +1,93 @@
+import { getDb } from "../index.js";
+function listConversations(limit = 50, offset = 0) {
+  const db = getDb();
+  return db.prepare(`
+    SELECT id, title, created_at, updated_at, project_id, parent_id
+    FROM conversations
+    ORDER BY updated_at DESC
+    LIMIT ? OFFSET ?
+  `).all(limit, offset);
+}
+function getConversation(id) {
+  const db = getDb();
+  const row = db.prepare(`
+    SELECT id, title, created_at, updated_at, project_id, parent_id
+    FROM conversations
+    WHERE id = ?
+  `).get(id);
+  return row || null;
+}
+function createConversation(input) {
+  const db = getDb();
+  const now = Date.now();
+  const title = input.title || "New conversation";
+  db.prepare(`
+    INSERT INTO conversations (id, title, created_at, updated_at, project_id, parent_id)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `).run(input.id, title, now, now, input.projectId || null, input.parentId || null);
+  return {
+    id: input.id,
+    title,
+    created_at: now,
+    updated_at: now,
+    project_id: input.projectId || null,
+    parent_id: input.parentId || null
+  };
+}
+function updateConversation(id, input) {
+  const db = getDb();
+  const existing = getConversation(id);
+  if (!existing) return null;
+  const now = Date.now();
+  const updates = ["updated_at = ?"];
+  const values = [now];
+  if (input.title !== void 0) {
+    updates.push("title = ?");
+    values.push(input.title);
+  }
+  if (input.projectId !== void 0) {
+    updates.push("project_id = ?");
+    values.push(input.projectId);
+  }
+  if (input.parentId !== void 0) {
+    updates.push("parent_id = ?");
+    values.push(input.parentId);
+  }
+  values.push(id);
+  db.prepare(`UPDATE conversations SET ${updates.join(", ")} WHERE id = ?`).run(...values);
+  return getConversation(id);
+}
+function deleteConversation(id) {
+  const db = getDb();
+  const result = db.prepare("DELETE FROM conversations WHERE id = ?").run(id);
+  return result.changes > 0;
+}
+function touchConversation(id) {
+  const db = getDb();
+  db.prepare("UPDATE conversations SET updated_at = ? WHERE id = ?").run(Date.now(), id);
+}
+function updateLinerNotes(id, linerNotes) {
+  const db = getDb();
+  db.prepare("UPDATE conversations SET liner_notes = ?, updated_at = ? WHERE id = ?").run(linerNotes, Date.now(), id);
+}
+function getLinerNotes(id) {
+  const db = getDb();
+  const row = db.prepare("SELECT liner_notes FROM conversations WHERE id = ?").get(id);
+  return row?.liner_notes || null;
+}
+function countConversations() {
+  const db = getDb();
+  const row = db.prepare("SELECT COUNT(*) as count FROM conversations").get();
+  return row.count;
+}
+export {
+  countConversations,
+  createConversation,
+  deleteConversation,
+  getConversation,
+  getLinerNotes,
+  listConversations,
+  touchConversation,
+  updateConversation,
+  updateLinerNotes
+};

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

@@ -0,0 +1,137 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { resetTestDb } from "../../test/helpers.js";
+import {
+  listConversations,
+  getConversation,
+  createConversation,
+  updateConversation,
+  deleteConversation,
+  touchConversation,
+  updateLinerNotes,
+  getLinerNotes,
+  countConversations
+} from "./conversations.js";
+beforeEach(() => {
+  resetTestDb();
+});
+describe("createConversation", () => {
+  it("creates with default title", () => {
+    const conv = createConversation({ id: "c1" });
+    expect(conv.id).toBe("c1");
+    expect(conv.title).toBe("New conversation");
+    expect(conv.created_at).toBeGreaterThan(0);
+    expect(conv.updated_at).toBe(conv.created_at);
+  });
+  it("creates with custom title", () => {
+    const conv = createConversation({ id: "c1", title: "My Chat" });
+    expect(conv.title).toBe("My Chat");
+  });
+  it("creates with project and parent IDs", () => {
+    const conv = createConversation({ id: "c1", projectId: "proj1", parentId: "parent1" });
+    expect(conv.project_id).toBe("proj1");
+    expect(conv.parent_id).toBe("parent1");
+  });
+});
+describe("getConversation", () => {
+  it("returns existing conversation", () => {
+    createConversation({ id: "c1", title: "Test" });
+    const conv = getConversation("c1");
+    expect(conv).not.toBeNull();
+    expect(conv.title).toBe("Test");
+  });
+  it("returns null for non-existing", () => {
+    expect(getConversation("nope")).toBeNull();
+  });
+});
+describe("listConversations", () => {
+  it("returns empty list initially", () => {
+    expect(listConversations()).toEqual([]);
+  });
+  it("returns conversations ordered by updated_at DESC", () => {
+    createConversation({ id: "c1", title: "First" });
+    createConversation({ id: "c2", title: "Second" });
+    touchConversation("c1");
+    const list = listConversations();
+    expect(list).toHaveLength(2);
+    expect(list[0].id).toBe("c1");
+    expect(list[1].id).toBe("c2");
+  });
+  it("respects limit and offset", () => {
+    createConversation({ id: "c1" });
+    createConversation({ id: "c2" });
+    createConversation({ id: "c3" });
+    const page1 = listConversations(2, 0);
+    expect(page1).toHaveLength(2);
+    const page2 = listConversations(2, 2);
+    expect(page2).toHaveLength(1);
+  });
+});
+describe("updateConversation", () => {
+  it("updates title", () => {
+    createConversation({ id: "c1", title: "Old" });
+    const updated = updateConversation("c1", { title: "New" });
+    expect(updated.title).toBe("New");
+    expect(updated.updated_at).toBeGreaterThanOrEqual(updated.created_at);
+  });
+  it("returns null for non-existing", () => {
+    expect(updateConversation("nope", { title: "x" })).toBeNull();
+  });
+  it("updates projectId and parentId", () => {
+    createConversation({ id: "c1" });
+    const updated = updateConversation("c1", { projectId: "p1", parentId: "par1" });
+    expect(updated.project_id).toBe("p1");
+    expect(updated.parent_id).toBe("par1");
+  });
+});
+describe("deleteConversation", () => {
+  it("deletes existing conversation", () => {
+    createConversation({ id: "c1" });
+    expect(deleteConversation("c1")).toBe(true);
+    expect(getConversation("c1")).toBeNull();
+  });
+  it("returns false for non-existing", () => {
+    expect(deleteConversation("nope")).toBe(false);
+  });
+});
+describe("touchConversation", () => {
+  it("updates the updated_at timestamp", () => {
+    const conv = createConversation({ id: "c1" });
+    const originalUpdatedAt = conv.updated_at;
+    touchConversation("c1");
+    const touched = getConversation("c1");
+    expect(touched.updated_at).toBeGreaterThanOrEqual(originalUpdatedAt);
+  });
+});
+describe("liner notes", () => {
+  it("returns null when no notes set", () => {
+    createConversation({ id: "c1" });
+    expect(getLinerNotes("c1")).toBeNull();
+  });
+  it("sets and gets liner notes", () => {
+    createConversation({ id: "c1" });
+    updateLinerNotes("c1", "# My Notes\nSome content");
+    expect(getLinerNotes("c1")).toBe("# My Notes\nSome content");
+  });
+  it("clears liner notes with null", () => {
+    createConversation({ id: "c1" });
+    updateLinerNotes("c1", "notes");
+    updateLinerNotes("c1", null);
+    expect(getLinerNotes("c1")).toBeNull();
+  });
+});
+describe("countConversations", () => {
+  it("returns 0 when empty", () => {
+    expect(countConversations()).toBe(0);
+  });
+  it("returns correct count after inserts", () => {
+    createConversation({ id: "c1" });
+    createConversation({ id: "c2" });
+    expect(countConversations()).toBe(2);
+  });
+  it("decrements after delete", () => {
+    createConversation({ id: "c1" });
+    createConversation({ id: "c2" });
+    deleteConversation("c1");
+    expect(countConversations()).toBe(1);
+  });
+});

package/server/db/repositories/jobs.js

@@ -0,0 +1,128 @@
+import { getDb } from "../index.js";
+function createJob(input) {
+  const db = getDb();
+  const now = Date.now();
+  db.prepare(`
+    INSERT INTO jobs (id, conversation_id, prompt, status, source, created_at, updated_at)
+    VALUES (?, ?, ?, 'queued', ?, ?, ?)
+  `).run(input.id, input.conversationId, input.prompt, input.source || "web", now, now);
+  return getJob(input.id);
+}
+function getJob(id) {
+  const db = getDb();
+  const row = db.prepare(`
+    SELECT id, conversation_id, prompt, status, source, result, error, pid,
+           created_at, updated_at, started_at, completed_at
+    FROM jobs WHERE id = ?
+  `).get(id);
+  return row || null;
+}
+function listJobs(filters, limit = 50) {
+  const db = getDb();
+  const conditions = [];
+  const params = [];
+  if (filters?.status) {
+    conditions.push("status = ?");
+    params.push(filters.status);
+  }
+  if (filters?.conversationId) {
+    conditions.push("conversation_id = ?");
+    params.push(filters.conversationId);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  params.push(limit);
+  return db.prepare(`
+    SELECT id, conversation_id, prompt, status, source, result, error, pid,
+           created_at, updated_at, started_at, completed_at
+    FROM jobs ${where}
+    ORDER BY created_at DESC
+    LIMIT ?
+  `).all(...params);
+}
+function updateJob(id, input) {
+  const db = getDb();
+  const updates = ["updated_at = ?"];
+  const values = [Date.now()];
+  if (input.status !== void 0) {
+    updates.push("status = ?");
+    values.push(input.status);
+  }
+  if (input.result !== void 0) {
+    updates.push("result = ?");
+    values.push(input.result);
+  }
+  if (input.error !== void 0) {
+    updates.push("error = ?");
+    values.push(input.error);
+  }
+  if (input.pid !== void 0) {
+    updates.push("pid = ?");
+    values.push(input.pid);
+  }
+  if (input.started_at !== void 0) {
+    updates.push("started_at = ?");
+    values.push(input.started_at);
+  }
+  if (input.completed_at !== void 0) {
+    updates.push("completed_at = ?");
+    values.push(input.completed_at);
+  }
+  values.push(id);
+  db.prepare(`UPDATE jobs SET ${updates.join(", ")} WHERE id = ?`).run(...values);
+  return getJob(id);
+}
+function createJobEvent(input) {
+  const db = getDb();
+  const timestamp = Date.now();
+  const result = db.prepare(`
+    INSERT INTO job_events (job_id, event_type, data, timestamp)
+    VALUES (?, ?, ?, ?)
+  `).run(input.jobId, input.eventType, input.data || null, timestamp);
+  return {
+    id: Number(result.lastInsertRowid),
+    job_id: input.jobId,
+    event_type: input.eventType,
+    data: input.data || null,
+    timestamp
+  };
+}
+function getJobEvents(jobId, since) {
+  const db = getDb();
+  if (since) {
+    return db.prepare(`
+      SELECT id, job_id, event_type, data, timestamp
+      FROM job_events
+      WHERE job_id = ? AND timestamp > ?
+      ORDER BY timestamp ASC
+    `).all(jobId, since);
+  }
+  return db.prepare(`
+    SELECT id, job_id, event_type, data, timestamp
+    FROM job_events
+    WHERE job_id = ?
+    ORDER BY timestamp ASC
+  `).all(jobId);
+}
+function cleanupStaleJobs() {
+  const db = getDb();
+  const result = db.prepare(`
+    UPDATE jobs SET status = 'failed', error = 'Server restarted', updated_at = ?, completed_at = ?
+    WHERE status IN ('queued', 'running')
+  `).run(Date.now(), Date.now());
+  return result.changes;
+}
+function deleteJob(id) {
+  const db = getDb();
+  const result = db.prepare("DELETE FROM jobs WHERE id = ?").run(id);
+  return result.changes > 0;
+}
+export {
+  cleanupStaleJobs,
+  createJob,
+  createJobEvent,
+  deleteJob,
+  getJob,
+  getJobEvents,
+  listJobs,
+  updateJob
+};

package/server/db/repositories/messages.js

@@ -0,0 +1,98 @@
+import { getDb } from "../index.js";
+import { touchConversation } from "./conversations.js";
+function getMessagesForConversation(conversationId) {
+  const db = getDb();
+  return db.prepare(`
+    SELECT id, conversation_id, role, content, timestamp, position, source
+    FROM messages
+    WHERE conversation_id = ?
+    ORDER BY position ASC
+  `).all(conversationId);
+}
+function getImagesForMessage(messageId) {
+  const db = getDb();
+  return db.prepare(`
+    SELECT id, message_id, data_url, file_name, description, position
+    FROM message_images
+    WHERE message_id = ?
+    ORDER BY position ASC
+  `).all(messageId);
+}
+function getImagesForMessages(messageIds) {
+  if (messageIds.length === 0) return /* @__PURE__ */ new Map();
+  const db = getDb();
+  const placeholders = messageIds.map(() => "?").join(", ");
+  const rows = db.prepare(`
+    SELECT id, message_id, data_url, file_name, description, position
+    FROM message_images
+    WHERE message_id IN (${placeholders})
+    ORDER BY position ASC
+  `).all(...messageIds);
+  const imageMap = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (!imageMap.has(row.message_id)) {
+      imageMap.set(row.message_id, []);
+    }
+    imageMap.get(row.message_id).push(row);
+  }
+  return imageMap;
+}
+function createMessage(input) {
+  const db = getDb();
+  const timestamp = input.timestamp || Date.now();
+  const source = input.source || "web";
+  const posRow = db.prepare(`
+    SELECT COALESCE(MAX(position), -1) + 1 as next_pos
+    FROM messages
+    WHERE conversation_id = ?
+  `).get(input.conversationId);
+  const position = posRow.next_pos;
+  db.prepare(`
+    INSERT INTO messages (id, conversation_id, role, content, timestamp, position, source)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `).run(input.id, input.conversationId, input.role, input.content, timestamp, position, source);
+  if (input.images && input.images.length > 0) {
+    const insertImage = db.prepare(`
+      INSERT INTO message_images (id, message_id, data_url, file_name, description, position)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `);
+    for (let i = 0; i < input.images.length; i++) {
+      const img = input.images[i];
+      insertImage.run(img.id, input.id, img.dataUrl, img.fileName, img.description || null, i);
+    }
+  }
+  touchConversation(input.conversationId);
+  return {
+    id: input.id,
+    conversation_id: input.conversationId,
+    role: input.role,
+    content: input.content,
+    timestamp,
+    position,
+    source
+  };
+}
+function updateImageDescription(imageId, description) {
+  const db = getDb();
+  const result = db.prepare("UPDATE message_images SET description = ? WHERE id = ?").run(description, imageId);
+  return result.changes > 0;
+}
+function deleteMessage(id) {
+  const db = getDb();
+  const result = db.prepare("DELETE FROM messages WHERE id = ?").run(id);
+  return result.changes > 0;
+}
+function countMessagesInConversation(conversationId) {
+  const db = getDb();
+  const row = db.prepare("SELECT COUNT(*) as count FROM messages WHERE conversation_id = ?").get(conversationId);
+  return row.count;
+}
+export {
+  countMessagesInConversation,
+  createMessage,
+  deleteMessage,
+  getImagesForMessage,
+  getImagesForMessages,
+  getMessagesForConversation,
+  updateImageDescription
+};