@assistkick/create 1.9.0 → 1.11.0

package/templates/assistkick-product-system/packages/backend/src/services/chat_session_service.test.ts

@@ -0,0 +1,217 @@
+import { describe, it, mock, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { ChatSessionService } from './chat_session_service.ts';
+
+const createMockDb = () => {
+  let selectResults: any[][] = [];
+  let selectCallIndex = 0;
+  let deleteCallCount = 0;
+
+  const db = {
+    select: mock.fn(() => ({
+      from: mock.fn(() => ({
+        where: mock.fn(() => {
+          const result = selectResults[selectCallIndex] || [];
+          selectCallIndex++;
+          return Object.assign(result, {
+            orderBy: mock.fn(() => result),
+          });
+        }),
+        orderBy: mock.fn(() => {
+          const result = selectResults[selectCallIndex] || [];
+          selectCallIndex++;
+          return result;
+        }),
+      })),
+    })),
+    insert: mock.fn(() => ({
+      values: mock.fn(() => Promise.resolve()),
+    })),
+    update: mock.fn(() => ({
+      set: mock.fn(() => ({
+        where: mock.fn(() => Promise.resolve()),
+      })),
+    })),
+    delete: mock.fn(() => ({
+      where: mock.fn(() => {
+        deleteCallCount++;
+        return Promise.resolve();
+      }),
+    })),
+    _setSelectResults: (results: any[][]) => {
+      selectResults = results;
+      selectCallIndex = 0;
+    },
+    _getDeleteCallCount: () => deleteCallCount,
+  };
+
+  return db;
+};
+
+const createService = (db: any) => {
+  return new ChatSessionService({
+    getDb: () => db,
+    log: mock.fn(),
+  });
+};
+
+describe('ChatSessionService', () => {
+  let db: ReturnType<typeof createMockDb>;
+  let service: ChatSessionService;
+
+  beforeEach(() => {
+    db = createMockDb();
+    service = createService(db);
+  });
+
+  describe('generateId', () => {
+    it('returns an id with csess_ prefix', () => {
+      const id = service.generateId();
+      assert.ok(id.startsWith('csess_'));
+      assert.ok(id.length > 6);
+    });
+
+    it('generates unique ids', () => {
+      const id1 = service.generateId();
+      const id2 = service.generateId();
+      assert.notEqual(id1, id2);
+    });
+  });
+
+  describe('formatSessionName', () => {
+    it('formats date as Chat DD/MM/YY HH:MM', () => {
+      const date = new Date('2026-03-11T14:30:00.000Z');
+      const name = service.formatSessionName(date);
+      // Format depends on timezone, but pattern should match
+      assert.ok(name.startsWith('Chat '));
+      assert.match(name, /^Chat \d{2}\/\d{2}\/\d{2} \d{2}:\d{2}$/);
+    });
+  });
+
+  describe('listSessions', () => {
+    it('returns sessions for a project', async () => {
+      const mockSessions = [
+        {
+          id: 'csess_abc',
+          claudeSessionId: 'uuid-1',
+          projectId: 'proj_001',
+          name: 'Chat 11/03/26 14:30',
+          permissionMode: null,
+          createdAt: '2026-03-11T14:30:00.000Z',
+          updatedAt: '2026-03-11T14:30:00.000Z',
+        },
+      ];
+      db._setSelectResults([mockSessions]);
+
+      const sessions = await service.listSessions('proj_001');
+      assert.equal(sessions.length, 1);
+      assert.equal(sessions[0].id, 'csess_abc');
+      assert.equal(sessions[0].projectId, 'proj_001');
+    });
+
+    it('returns empty array when no sessions exist', async () => {
+      db._setSelectResults([[]]);
+      const sessions = await service.listSessions('proj_001');
+      assert.equal(sessions.length, 0);
+    });
+  });
+
+  describe('getSession', () => {
+    it('returns session when found', async () => {
+      const mockSession = {
+        id: 'csess_abc',
+        claudeSessionId: 'uuid-1',
+        projectId: 'proj_001',
+        name: 'Chat 11/03/26 14:30',
+        permissionMode: null,
+        createdAt: '2026-03-11T14:30:00.000Z',
+        updatedAt: '2026-03-11T14:30:00.000Z',
+      };
+      db._setSelectResults([[mockSession]]);
+
+      const session = await service.getSession('csess_abc');
+      assert.ok(session);
+      assert.equal(session.id, 'csess_abc');
+    });
+
+    it('returns undefined when session not found', async () => {
+      db._setSelectResults([[]]);
+      const session = await service.getSession('csess_nonexistent');
+      assert.equal(session, undefined);
+    });
+  });
+
+  describe('createSession', () => {
+    it('creates a session and returns it', async () => {
+      const session = await service.createSession('proj_001');
+
+      assert.ok(session.id.startsWith('csess_'));
+      assert.ok(session.claudeSessionId);
+      assert.equal(session.projectId, 'proj_001');
+      assert.ok(session.name.startsWith('Chat '));
+      assert.equal(session.permissionMode, null);
+      assert.ok(session.createdAt);
+      assert.ok(session.updatedAt);
+
+      assert.equal(db.insert.mock.calls.length, 1);
+    });
+  });
+
+  describe('renameSession', () => {
+    it('renames an existing session', async () => {
+      const mockSession = {
+        id: 'csess_abc',
+        claudeSessionId: 'uuid-1',
+        projectId: 'proj_001',
+        name: 'Old Name',
+        permissionMode: null,
+        createdAt: '2026-03-11T14:30:00.000Z',
+        updatedAt: '2026-03-11T14:30:00.000Z',
+      };
+      db._setSelectResults([[mockSession]]);
+
+      const result = await service.renameSession('csess_abc', 'New Name');
+      assert.ok(result);
+      assert.equal(result.name, 'New Name');
+      assert.equal(db.update.mock.calls.length, 1);
+    });
+
+    it('returns undefined when session not found', async () => {
+      db._setSelectResults([[]]);
+      const result = await service.renameSession('csess_nonexistent', 'New Name');
+      assert.equal(result, undefined);
+    });
+  });
+
+  describe('deleteSession', () => {
+    it('deletes an existing session', async () => {
+      const mockSession = {
+        id: 'csess_abc',
+        claudeSessionId: 'uuid-1',
+        projectId: 'proj_001',
+        name: 'Chat 11/03/26 14:30',
+        permissionMode: null,
+        createdAt: '2026-03-11T14:30:00.000Z',
+        updatedAt: '2026-03-11T14:30:00.000Z',
+      };
+      db._setSelectResults([[mockSession]]);
+
+      const result = await service.deleteSession('csess_abc');
+      assert.equal(result, true);
+      assert.equal(db.delete.mock.calls.length, 1);
+    });
+
+    it('returns false when session not found', async () => {
+      db._setSelectResults([[]]);
+      const result = await service.deleteSession('csess_nonexistent');
+      assert.equal(result, false);
+    });
+  });
+
+  describe('touchSession', () => {
+    it('updates the updatedAt timestamp', async () => {
+      await service.touchSession('csess_abc');
+      assert.equal(db.update.mock.calls.length, 1);
+    });
+  });
+});

package/templates/assistkick-product-system/packages/backend/src/services/chat_session_service.ts

@@ -0,0 +1,188 @@
+/**
+ * ChatSessionService — manages chat v2 sessions scoped to projects.
+ * Sessions are persisted in the database. Each session maps to a
+ * Claude Code session ID (UUID) used by the CLI bridge.
+ */
+
+import { randomBytes, randomUUID } from 'node:crypto';
+import { desc, eq, and } from 'drizzle-orm';
+import { chatSessions } from '@assistkick/shared/db/schema.js';
+
+interface ChatSessionServiceDeps {
+  getDb: () => any;
+  log: (tag: string, ...args: unknown[]) => void;
+}
+
+export interface ChatSessionInfo {
+  id: string;
+  claudeSessionId: string;
+  projectId: string;
+  name: string;
+  permissionMode: string | null;
+  continuationContext: string | null;
+  systemPrompt: string | null;
+  contextUsageJson: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export class ChatSessionService {
+  private readonly getDb: ChatSessionServiceDeps['getDb'];
+  private readonly log: ChatSessionServiceDeps['log'];
+
+  constructor({ getDb, log }: ChatSessionServiceDeps) {
+    this.getDb = getDb;
+    this.log = log;
+  }
+
+  generateId = (): string => {
+    const hex = randomBytes(3).toString('hex');
+    return `csess_${hex}`;
+  };
+
+  formatSessionName = (date: Date): string => {
+    const dd = String(date.getDate()).padStart(2, '0');
+    const mm = String(date.getMonth() + 1).padStart(2, '0');
+    const yy = String(date.getFullYear()).slice(2);
+    const hh = String(date.getHours()).padStart(2, '0');
+    const min = String(date.getMinutes()).padStart(2, '0');
+    return `Chat ${dd}/${mm}/${yy} ${hh}:${min}`;
+  };
+
+  /** List all chat sessions for a given project, newest first. */
+  listSessions = async (projectId: string): Promise<ChatSessionInfo[]> => {
+    const db = this.getDb();
+    const rows = await db
+      .select()
+      .from(chatSessions)
+      .where(eq(chatSessions.projectId, projectId))
+      .orderBy(desc(chatSessions.updatedAt));
+    return rows.map((r: any) => ({
+      id: r.id,
+      claudeSessionId: r.claudeSessionId,
+      projectId: r.projectId,
+      name: r.name,
+      permissionMode: r.permissionMode,
+      continuationContext: r.continuationContext,
+      systemPrompt: r.systemPrompt,
+      contextUsageJson: r.contextUsageJson,
+      createdAt: r.createdAt,
+      updatedAt: r.updatedAt,
+    }));
+  };
+
+  /** Get a single session by ID. */
+  getSession = async (sessionId: string): Promise<ChatSessionInfo | undefined> => {
+    const db = this.getDb();
+    const rows = await db
+      .select()
+      .from(chatSessions)
+      .where(eq(chatSessions.id, sessionId));
+    if (rows.length === 0) return undefined;
+    const r = rows[0];
+    return {
+      id: r.id,
+      claudeSessionId: r.claudeSessionId,
+      projectId: r.projectId,
+      name: r.name,
+      permissionMode: r.permissionMode,
+      continuationContext: r.continuationContext,
+      systemPrompt: r.systemPrompt,
+      contextUsageJson: r.contextUsageJson,
+      createdAt: r.createdAt,
+      updatedAt: r.updatedAt,
+    };
+  };
+
+  /** Create a new chat session for a project, optionally with compacted continuation context. */
+  createSession = async (projectId: string, continuationContext?: string): Promise<ChatSessionInfo> => {
+    const id = this.generateId();
+    const claudeSessionId = randomUUID();
+    const now = new Date();
+    const name = this.formatSessionName(now);
+    const nowIso = now.toISOString();
+
+    const db = this.getDb();
+    await db.insert(chatSessions).values({
+      id,
+      claudeSessionId,
+      projectId,
+      name,
+      continuationContext: continuationContext ?? null,
+      createdAt: nowIso,
+      updatedAt: nowIso,
+    });
+
+    this.log('CHAT_SESSION', `Created session "${name}" (${id}) for project ${projectId}${continuationContext ? ' [with continuation]' : ''}`);
+
+    return {
+      id,
+      claudeSessionId,
+      projectId,
+      name,
+      permissionMode: null,
+      continuationContext: continuationContext ?? null,
+      systemPrompt: null,
+      contextUsageJson: null,
+      createdAt: nowIso,
+      updatedAt: nowIso,
+    };
+  };
+
+  /** Rename a chat session. */
+  renameSession = async (sessionId: string, name: string): Promise<ChatSessionInfo | undefined> => {
+    const session = await this.getSession(sessionId);
+    if (!session) return undefined;
+
+    const db = this.getDb();
+    const now = new Date().toISOString();
+    await db
+      .update(chatSessions)
+      .set({ name, updatedAt: now })
+      .where(eq(chatSessions.id, sessionId));
+
+    this.log('CHAT_SESSION', `Renamed session ${sessionId} to "${name}"`);
+
+    return { ...session, name, updatedAt: now };
+  };
+
+  /** Delete a chat session permanently. */
+  deleteSession = async (sessionId: string): Promise<boolean> => {
+    const session = await this.getSession(sessionId);
+    if (!session) return false;
+
+    const db = this.getDb();
+    await db.delete(chatSessions).where(eq(chatSessions.id, sessionId));
+
+    this.log('CHAT_SESSION', `Deleted session ${sessionId}`);
+    return true;
+  };
+
+  /** Touch the updatedAt timestamp for a session. */
+  touchSession = async (sessionId: string): Promise<void> => {
+    const db = this.getDb();
+    const now = new Date().toISOString();
+    await db
+      .update(chatSessions)
+      .set({ updatedAt: now })
+      .where(eq(chatSessions.id, sessionId));
+  };
+
+  /** Update context usage JSON for a session. */
+  updateContextUsage = async (sessionId: string, contextUsageJson: string): Promise<void> => {
+    const db = this.getDb();
+    await db
+      .update(chatSessions)
+      .set({ contextUsageJson })
+      .where(eq(chatSessions.id, sessionId));
+  };
+
+  /** Update the composed system prompt for a session. */
+  updateSystemPrompt = async (sessionId: string, systemPrompt: string): Promise<void> => {
+    const db = this.getDb();
+    await db
+      .update(chatSessions)
+      .set({ systemPrompt })
+      .where(eq(chatSessions.id, sessionId));
+  };
+}