@openchambery/web 1.19.7-beta.9 → 1.19.8-beta.1

package/server/lib/assistants/assign.test.js

@@ -0,0 +1,118 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { describe, expect, it, vi } from 'vitest';
+import {
+  ASSIGN_CODES,
+  PROJECT_REQUIRED_MESSAGE,
+  assignSession,
+  isManagedAssistantWorkspace,
+  resolveAssignDirectory,
+} from './assign.js';
+
+const root = () => fs.mkdtempSync(path.join(os.tmpdir(), 'assign-'));
+
+describe('resolveAssignDirectory', () => {
+  it('requires a registered project root', () => {
+    expect(() => resolveAssignDirectory({ allowedRoots: [] })).toThrowError(
+      expect.objectContaining({ code: ASSIGN_CODES.PROJECT_REQUIRED, message: PROJECT_REQUIRED_MESSAGE }),
+    );
+  });
+
+  it('rejects managed assistant-workspaces even when they sit under an allowed root', () => {
+    const directory = root();
+    const managed = path.join(directory, 'assistant-workspaces', 'asst_1');
+    fs.mkdirSync(managed, { recursive: true });
+    expect(isManagedAssistantWorkspace(managed, path.join(directory, 'assistant-workspaces'))).toBe(true);
+    expect(() => resolveAssignDirectory({
+      directory: managed,
+      allowedRoots: [directory],
+      managedWorkspaceRoot: path.join(directory, 'assistant-workspaces'),
+    })).toThrowError(expect.objectContaining({ code: ASSIGN_CODES.WORKSPACE_FORBIDDEN }));
+  });
+
+  it('resolves an existing worktree for a branch and refuses a missing one', () => {
+    const directory = root();
+    const project = path.join(directory, 'project');
+    const worktree = path.join(directory, 'worktrees', 'login');
+    fs.mkdirSync(project, { recursive: true });
+    fs.mkdirSync(worktree, { recursive: true });
+    expect(resolveAssignDirectory({
+      projectPath: project,
+      branch: 'feat-login',
+      allowedRoots: [directory],
+      managedWorkspaceRoot: path.join(directory, 'assistant-workspaces'),
+      worktrees: [{ branch: 'feat-login', path: worktree }],
+    })).toBe(fs.realpathSync(worktree));
+    expect(() => resolveAssignDirectory({
+      projectPath: project,
+      branch: 'missing',
+      allowedRoots: [directory],
+      managedWorkspaceRoot: path.join(directory, 'assistant-workspaces'),
+      worktrees: [{ branch: 'feat-login', path: worktree }],
+    })).toThrowError(expect.objectContaining({ code: ASSIGN_CODES.WORKTREE_NOT_FOUND }));
+  });
+});
+
+describe('assignSession', () => {
+  it('creates a visible worker session and prompts it', async () => {
+    const directory = root();
+    const project = path.join(directory, 'app');
+    fs.mkdirSync(project, { recursive: true });
+    const createSession = vi.fn(async (input) => ({ data: { id: 'ses_worker' }, input }));
+    const promptExisting = vi.fn(async () => ({ response: { status: 204 } }));
+    const assigned = await assignSession({
+      prompt: 'Fix login',
+      projectPath: project,
+      title: 'Login',
+      assistant: { id: 'asst_1', name: 'Ada', providerID: 'openai', modelID: 'gpt-5.2' },
+      allowedRoots: [directory],
+      managedWorkspaceRoot: path.join(directory, 'assistant-workspaces'),
+      createSession,
+      promptExisting,
+    });
+    expect(assigned).toMatchObject({
+      sessionID: 'ses_worker',
+      directory: fs.realpathSync(project),
+      title: 'Login',
+      status: 'busy',
+      reused: false,
+    });
+    expect(createSession).toHaveBeenCalledWith(expect.objectContaining({
+      directory: fs.realpathSync(project),
+      title: 'Login',
+      metadata: {
+        openchamber: {
+          assigned: { from: 'contact', assistantID: 'asst_1', name: 'Ada' },
+        },
+      },
+    }));
+    expect(createSession.mock.calls[0][0].metadata.openchamber.assistant).toBeUndefined();
+    expect(promptExisting).toHaveBeenCalledWith(expect.objectContaining({
+      sessionID: 'ses_worker',
+      directory: fs.realpathSync(project),
+      parts: [{ type: 'text', text: 'Fix login' }],
+      model: { providerID: 'openai', modelID: 'gpt-5.2' },
+    }));
+  });
+
+  it('reuses an existing session without creating another', async () => {
+    const directory = root();
+    fs.mkdirSync(directory, { recursive: true });
+    const createSession = vi.fn();
+    const promptExisting = vi.fn(async () => ({ response: { status: 204 } }));
+    const assigned = await assignSession({
+      prompt: 'Continue login',
+      sessionID: 'ses_existing',
+      directory,
+      assistant: { providerID: 'p', modelID: 'm' },
+      allowedRoots: [directory],
+      managedWorkspaceRoot: path.join(directory, 'assistant-workspaces'),
+      createSession,
+      promptExisting,
+    });
+    expect(assigned).toMatchObject({ sessionID: 'ses_existing', reused: true, status: 'busy' });
+    expect(createSession).not.toHaveBeenCalled();
+    expect(promptExisting).toHaveBeenCalledWith(expect.objectContaining({ sessionID: 'ses_existing' }));
+  });
+});

package/server/lib/assistants/bubbles.js

@@ -0,0 +1,45 @@
+const SENTENCE = /(?<=[.!?])\s+(?=[A-Z“"‘])/u;
+const CONTACT_PLANNING = /\b(let me think|i should|i need to|i'll call|i will call|the user (said|wants|asked)|actually,?|hmm\.?|assign_session|list_projects|list_sessions|create_assistant|schedule_task|tool call|projectPath)\b/i;
+
+/**
+ * A short spoken contact line (not chain-of-thought). Shown before a tool and kept.
+ */
+export function isContactSpokenPreamble(text, { maxChars = 80 } = {}) {
+  if (typeof text !== 'string') return false;
+  const next = text.replace(/\r\n/g, '\n').trim();
+  if (!next || next.length > maxChars) return false;
+  if (/\n{2,}/u.test(next)) return false;
+  if (/```/.test(next)) return false;
+  if (CONTACT_PLANNING.test(next)) return false;
+  return true;
+}
+
+/**
+ * Split model output into short contact bubbles.
+ * Blank-line paragraphs first; long paragraphs split on sentence boundaries.
+ */
+export function splitContactBubbles(text, { maxChars = 280 } = {}) {
+  const raw = typeof text === 'string' ? text.replace(/\r\n/g, '\n').trim() : '';
+  if (!raw) return [];
+  const paragraphs = raw.split(/\n{2,}/u).map((part) => part.trim()).filter(Boolean);
+  const bubbles = [];
+  for (const paragraph of paragraphs) {
+    if (paragraph.length <= maxChars) {
+      bubbles.push(paragraph);
+      continue;
+    }
+    const sentences = paragraph.split(SENTENCE).map((part) => part.trim()).filter(Boolean);
+    let current = '';
+    for (const sentence of sentences) {
+      const next = current ? `${current} ${sentence}` : sentence;
+      if (next.length > maxChars && current) {
+        bubbles.push(current);
+        current = sentence;
+      } else {
+        current = next;
+      }
+    }
+    if (current) bubbles.push(current);
+  }
+  return bubbles.length > 0 ? bubbles : [raw];
+}

package/server/lib/assistants/bubbles.test.js

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest'
+import { isContactSpokenPreamble, splitContactBubbles } from './bubbles.js'
+
+describe('splitContactBubbles', () => {
+  it('splits on blank lines into short bubbles', () => {
+    expect(splitContactBubbles('Hey.\n\nWant me to open the login session?')).toEqual([
+      'Hey.',
+      'Want me to open the login session?',
+    ])
+  })
+
+  it('keeps a single paragraph together', () => {
+    expect(splitContactBubbles('Just one bubble.')).toEqual(['Just one bubble.'])
+  })
+
+  it('returns an empty list for blank text', () => {
+    expect(splitContactBubbles('   \n\n  ')).toEqual([])
+  })
+})
+
+describe('isContactSpokenPreamble', () => {
+  it('accepts a short spoken line', () => {
+    expect(isContactSpokenPreamble('我去找一下')).toBe(true)
+    expect(isContactSpokenPreamble('On it.')).toBe(true)
+  })
+
+  it('rejects chain-of-thought and tool narration', () => {
+    expect(isContactSpokenPreamble('Let me think — I should match the project and call assign_session.')).toBe(false)
+    expect(isContactSpokenPreamble('I need to list_projects first.')).toBe(false)
+  })
+
+  it('rejects long or multi-bubble text', () => {
+    expect(isContactSpokenPreamble('a'.repeat(81))).toBe(false)
+    expect(isContactSpokenPreamble('先找项目。\n\n再开会话。')).toBe(false)
+  })
+})

package/server/lib/assistants/cards.js

@@ -0,0 +1,148 @@
+export const CONTACT_CARD_TYPES = Object.freeze(['session', 'assistant', 'schedule']);
+const CARD_TYPES = new Set(CONTACT_CARD_TYPES);
+// Assign / create_assistant / schedule_task auto-insert these cards.
+// project | worktree | watch MUST reuse this slot. Do not invent a second card system.
+
+const isRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const string = (value) => (typeof value === 'string' && value.trim() ? value.trim() : '');
+
+const parseSessionCard = (value) => {
+  const sessionID = string(value.sessionID);
+  const directory = string(value.directory);
+  if (!sessionID || !directory) return null;
+  return {
+    type: 'card',
+    cardType: 'session',
+    sessionID,
+    directory,
+    title: string(value.title) || null,
+    status: string(value.status) || null,
+    branch: string(value.branch) || null,
+  };
+};
+
+const parseAssistantCard = (value) => {
+  const assistantID = string(value.assistantID);
+  const name = string(value.name);
+  const providerID = string(value.providerID);
+  const modelID = string(value.modelID);
+  if (!assistantID || !name || !providerID || !modelID) return null;
+  const mode = string(value.mode) === 'stateless' ? 'stateless' : 'continuous';
+  return {
+    type: 'card',
+    cardType: 'assistant',
+    assistantID,
+    name,
+    providerID,
+    modelID,
+    mode,
+  };
+};
+
+const parseScheduleCard = (value) => {
+  const taskID = string(value.taskID);
+  const projectID = string(value.projectID);
+  const name = string(value.name);
+  if (!taskID || !projectID || !name) return null;
+  return {
+    type: 'card',
+    cardType: 'schedule',
+    taskID,
+    projectID,
+    name,
+    kind: string(value.kind) || null,
+    time: string(value.time) || null,
+    timezone: string(value.timezone) || null,
+    prompt: string(value.prompt) || null,
+  };
+};
+
+/**
+ * First-class in-transcript card. Extensible via `cardType`.
+ * Session cards navigate with the existing session route, not markdown links.
+ */
+export function parseContactCard(value) {
+  if (!isRecord(value)) return null;
+  const cardType = string(value.cardType);
+  if (!CARD_TYPES.has(cardType)) return null;
+  if (cardType === 'session') return parseSessionCard(value);
+  if (cardType === 'assistant') return parseAssistantCard(value);
+  if (cardType === 'schedule') return parseScheduleCard(value);
+  return null;
+}
+
+function parseContactFilePart(value) {
+  if (!isRecord(value) || value.type !== 'file') return null;
+  const mime = string(value.mime);
+  const url = typeof value.url === 'string' && value.url.trim() ? value.url.trim() : '';
+  if (!mime || !url) return null;
+  const filename = string(value.filename);
+  return filename ? { type: 'file', mime, url, filename } : { type: 'file', mime, url };
+}
+
+export function parseContactPart(value) {
+  if (!isRecord(value)) return null;
+  if (value.type === 'text' && typeof value.text === 'string') {
+    return { type: 'text', text: value.text };
+  }
+  if (value.type === 'file') {
+    return parseContactFilePart(value);
+  }
+  if (value.type === 'card') {
+    return parseContactCard(value);
+  }
+  return null;
+}
+
+export function serializeContactPart(part, index) {
+  return {
+    id: part.id || `oc_contact_part:${index + 1}`,
+    ...part,
+  };
+}
+
+export function contactCardIdentity(card) {
+  if (!card || card.type !== 'card') return '';
+  if (card.cardType === 'session') return `session:${card.sessionID}:${card.directory}`;
+  if (card.cardType === 'assistant') return `assistant:${card.assistantID}`;
+  if (card.cardType === 'schedule') return `schedule:${card.projectID}:${card.taskID}`;
+  return card.cardType;
+}
+
+const createCardPart = (cardType, input, requiredMessage) => {
+  const card = parseContactCard({ type: 'card', cardType, ...input });
+  if (!card) {
+    const error = new Error(requiredMessage);
+    error.code = 'validation_error';
+    throw error;
+  }
+  return card;
+};
+
+/** Build a session card. Throws so insert paths fail closed. */
+export function createSessionCardPart(input) {
+  if (!string(input?.sessionID)) {
+    const error = new Error('sessionID is required');
+    error.code = 'validation_error';
+    throw error;
+  }
+  return createCardPart('session', input, 'Invalid session card');
+}
+
+export function createAssistantCardPart(input) {
+  if (!string(input?.assistantID)) {
+    const error = new Error('assistantID is required');
+    error.code = 'validation_error';
+    throw error;
+  }
+  return createCardPart('assistant', input, 'Invalid assistant card');
+}
+
+export function createScheduleCardPart(input) {
+  if (!string(input?.taskID) || !string(input?.projectID)) {
+    const error = new Error('taskID and projectID are required');
+    error.code = 'validation_error';
+    throw error;
+  }
+  return createCardPart('schedule', input, 'Invalid schedule card');
+}

package/server/lib/assistants/cards.test.js

@@ -0,0 +1,116 @@
+import { describe, expect, it } from 'vitest'
+import { CONTACT_CARD_TYPES, createSessionCardPart, parseContactCard, parseContactPart } from './cards.js'
+
+describe('contact cards', () => {
+  it('creates an extensible session card part', () => {
+    const part = createSessionCardPart({
+      sessionID: 'ses_1',
+      directory: '/tmp/project',
+      title: 'Fix login',
+      status: 'idle',
+      branch: 'feat-login',
+    })
+    expect(part).toEqual({
+      type: 'card',
+      cardType: 'session',
+      sessionID: 'ses_1',
+      directory: '/tmp/project',
+      title: 'Fix login',
+      status: 'idle',
+      branch: 'feat-login',
+    })
+    expect(CONTACT_CARD_TYPES).toContain('session')
+    expect(CONTACT_CARD_TYPES).toContain('assistant')
+    expect(CONTACT_CARD_TYPES).toContain('schedule')
+  })
+
+  it('creates assistant and schedule cards in the same slot', () => {
+    expect(parseContactCard({
+      cardType: 'assistant',
+      assistantID: 'asst_flow',
+      name: 'FlowQA',
+      providerID: 'opencode-go',
+      modelID: 'deepseek-v4-flash',
+    })).toEqual({
+      type: 'card',
+      cardType: 'assistant',
+      assistantID: 'asst_flow',
+      name: 'FlowQA',
+      providerID: 'opencode-go',
+      modelID: 'deepseek-v4-flash',
+      mode: 'continuous',
+    })
+    expect(parseContactCard({
+      cardType: 'schedule',
+      taskID: 'task_1',
+      projectID: 'proj_1',
+      name: 'Daily ping',
+      kind: 'daily',
+      time: '18:00',
+      timezone: 'Asia/Shanghai',
+      prompt: 'ping',
+    })).toMatchObject({
+      type: 'card',
+      cardType: 'schedule',
+      taskID: 'task_1',
+      projectID: 'proj_1',
+      name: 'Daily ping',
+      kind: 'daily',
+      time: '18:00',
+    })
+  })
+
+  it('rejects unknown card types so later types reuse this slot', () => {
+    expect(parseContactCard({
+      cardType: 'not-a-card',
+      sessionID: 'ses_1',
+      directory: '/tmp/project',
+    })).toBeNull()
+  })
+
+  it('parses contact file parts with optional filename', () => {
+    expect(parseContactPart({
+      type: 'file',
+      mime: 'image/png',
+      url: 'data:image/png;base64,aa',
+      filename: 'shot.png',
+    })).toEqual({
+      type: 'file',
+      mime: 'image/png',
+      url: 'data:image/png;base64,aa',
+      filename: 'shot.png',
+    })
+    expect(parseContactPart({
+      type: 'file',
+      mime: 'text/plain',
+      url: 'data:text/plain;base64,eA==',
+    })).toEqual({
+      type: 'file',
+      mime: 'text/plain',
+      url: 'data:text/plain;base64,eA==',
+    })
+    expect(parseContactPart({ type: 'file', mime: 'image/png' })).toBeNull()
+  })
+
+  it('requires a sessionID for session cards', () => {
+    expect(() => createSessionCardPart({ directory: '/tmp/project' })).toThrow(/sessionID/)
+  })
+
+  it('treats omitted branch as null so older persisted cards still parse', () => {
+    expect(parseContactCard({
+      cardType: 'session',
+      sessionID: 'ses_1',
+      directory: '/tmp/project',
+      title: 'Fix login',
+      status: 'idle',
+    })).toEqual({
+      type: 'card',
+      cardType: 'session',
+      sessionID: 'ses_1',
+      directory: '/tmp/project',
+      title: 'Fix login',
+      status: 'idle',
+      branch: null,
+    })
+  })
+})