@bbigbang/core 0.1.0

package/dist/web/promptContextSections.js

@@ -0,0 +1,242 @@
+export const EXACT_TARGET_HISTORY_SECTION_KINDS = new Set([
+    'recent_messages',
+    'history_cursor',
+    'recent_summary',
+    'unread_summary',
+]);
+const PROMPT_CONTEXT_HEADER_KIND_MAP = new Map([
+    ['[Active project]', 'active_project'],
+    ['[Workspace memory reminder]', 'workspace_memory_reminder'],
+    ['[Source-surface handoff reminder]', 'source_handoff_reminder'],
+    ['[Reminder guidance]', 'reminder_guidance'],
+    ['[UI panel guidance]', 'ui_panel_guidance'],
+    ['[Workspace tool guidance]', 'workspace_tool_guidance'],
+    ['[Library document guidance]', 'library_document_guidance'],
+    ['[Library documents]', 'library_documents'],
+    ['[Thread root message]', 'thread_root_message'],
+    ['[Bound task for this DM thread]', 'bound_task_dm_thread'],
+    ['[Recent messages on this exact target]', 'recent_messages'],
+    ['[History cursor]', 'history_cursor'],
+    ['[Recent summary]', 'recent_summary'],
+    ['[Unread summary]', 'unread_summary'],
+    ['[Inbox]', 'activation_pointer'],
+    ['[Context from DM]', 'dm_context_snapshot'],
+    ['[Active DM task threads]', 'dm_active_task_threads'],
+    ['[Active DM task-thread hint]', 'dm_active_task_thread_hint'],
+    ['[Active participants on this target]', 'participants'],
+    ['[Bound task-message for this thread]', 'bound_task_thread'],
+    ['[Task-message board summary]', 'task_board_summary'],
+    ['[Task-message board hint]', 'task_board_hint'],
+    ['[System status messages on this surface]', 'surface_system_status'],
+    ['[Relevant context hint]', 'relevant_context_hint'],
+    ['[Handoff capsule]', 'handoff_capsule'],
+    ['[Shared collaboration capsule]', 'shared_collaboration_capsule'],
+    ['[Conversation rolling summary]', 'conversation_rolling_summary'],
+]);
+const SAFE_SINGLE_SECTION_KINDS = new Set([
+    'active_project',
+    'workspace_memory_reminder',
+    'source_handoff_reminder',
+    'reminder_guidance',
+    'ui_panel_guidance',
+    'workspace_tool_guidance',
+    'library_document_guidance',
+    'library_documents',
+    'surface_system_status',
+    'relevant_context_hint',
+    'activation_pointer',
+    'handoff_capsule',
+    'shared_collaboration_capsule',
+    'conversation_rolling_summary',
+    'continuity',
+]);
+const LEADING_HEADER_SINGLE_SECTION_KINDS = new Set([
+    'active_project',
+    'workspace_memory_reminder',
+    'source_handoff_reminder',
+    'reminder_guidance',
+    'ui_panel_guidance',
+    'workspace_tool_guidance',
+    'library_document_guidance',
+    'library_documents',
+    'thread_root_message',
+    'bound_task_dm_thread',
+    'dm_context_snapshot',
+    'dm_active_task_threads',
+    'dm_active_task_thread_hint',
+    'participants',
+    'bound_task_thread',
+    'task_board_summary',
+    'task_board_hint',
+    'surface_system_status',
+    'relevant_context_hint',
+    'activation_pointer',
+    'handoff_capsule',
+    'shared_collaboration_capsule',
+    'conversation_rolling_summary',
+]);
+const EXACT_HISTORY_TEXT_FOLLOWUP_SECTION_KINDS = new Set([
+    'history_cursor',
+    'recent_summary',
+    'unread_summary',
+    'activation_pointer',
+    'source_handoff_reminder',
+    'reminder_guidance',
+    'ui_panel_guidance',
+    'workspace_tool_guidance',
+    'library_document_guidance',
+    'library_documents',
+    'dm_context_snapshot',
+    'dm_active_task_threads',
+    'dm_active_task_thread_hint',
+    'participants',
+    'bound_task_thread',
+    'bound_task_dm_thread',
+    'task_board_summary',
+    'task_board_hint',
+    'surface_system_status',
+]);
+export function createPromptContextSection(kind, text) {
+    const normalizedText = text?.trim();
+    if (!normalizedText)
+        return null;
+    return {
+        kind,
+        text: normalizedText,
+    };
+}
+export function renderPromptContextSections(sections) {
+    return (sections ?? [])
+        .map((section) => section.text.trim())
+        .filter(Boolean)
+        .join('\n\n');
+}
+export function inferSinglePromptContextSection(text, fallbackKind = 'other') {
+    const normalizedText = text?.trim();
+    if (!normalizedText)
+        return null;
+    const firstLine = normalizedText.split('\n', 1)[0]?.trim() ?? '';
+    const inferredKind = inferPromptContextHeaderKind(firstLine);
+    const kind = inferredKind && SAFE_SINGLE_SECTION_KINDS.has(inferredKind)
+        ? inferredKind
+        : fallbackKind;
+    return {
+        kind,
+        text: normalizedText,
+    };
+}
+export function inferLeadingPromptContextSection(text, fallbackKind = 'other') {
+    const normalizedText = text?.trim();
+    if (!normalizedText)
+        return null;
+    const firstLine = normalizedText.split('\n', 1)[0]?.trim() ?? '';
+    const inferredKind = inferPromptContextHeaderKind(firstLine);
+    let kind = fallbackKind;
+    if (inferredKind === 'continuity' || (inferredKind && LEADING_HEADER_SINGLE_SECTION_KINDS.has(inferredKind))) {
+        kind = inferredKind;
+    }
+    else if (inferredKind
+        && EXACT_TARGET_HISTORY_SECTION_KINDS.has(inferredKind)
+        && isPlatformExactTargetHistoryText(inferredKind, normalizedText)) {
+        kind = inferredKind;
+    }
+    return {
+        kind,
+        text: normalizedText,
+    };
+}
+export function inferPromptContextSections(text, fallbackKind = 'other') {
+    const normalizedText = text?.trim();
+    if (!normalizedText)
+        return [];
+    const lines = normalizedText.split('\n');
+    const blocks = [];
+    let current = [];
+    let previousLineWasBlank = false;
+    for (const line of lines) {
+        const trimmedLine = line.trim();
+        const nextKind = inferPromptContextHeaderKind(trimmedLine);
+        if (nextKind
+            && current.length > 0
+            && previousLineWasBlank
+            && shouldSplitPromptContextBlock(current, nextKind)) {
+            while (current.length > 0 && current.at(-1)?.trim() === '') {
+                current.pop();
+            }
+            blocks.push(current.join('\n').trim());
+            current = [line];
+            previousLineWasBlank = false;
+            continue;
+        }
+        current.push(line);
+        previousLineWasBlank = trimmedLine === '';
+    }
+    if (current.length > 0) {
+        blocks.push(current.join('\n').trim());
+    }
+    return blocks
+        .map((block) => inferLeadingPromptContextSection(block, fallbackKind))
+        .filter((section) => Boolean(section));
+}
+function inferPromptContextHeaderKind(line) {
+    return line.startsWith('Context (')
+        ? 'continuity'
+        : PROMPT_CONTEXT_HEADER_KIND_MAP.get(line);
+}
+function shouldSplitPromptContextBlock(currentLines, nextKind) {
+    const firstNonBlankLine = currentLines.find((line) => line.trim())?.trim() ?? '';
+    const currentKind = inferPromptContextHeaderKind(firstNonBlankLine);
+    if (currentKind && EXACT_TARGET_HISTORY_SECTION_KINDS.has(currentKind)) {
+        return EXACT_HISTORY_TEXT_FOLLOWUP_SECTION_KINDS.has(nextKind);
+    }
+    return true;
+}
+function isPlatformExactTargetHistoryText(kind, text) {
+    switch (kind) {
+        case 'recent_messages':
+            return /^\[Recent messages on this exact target\]\n/.test(text)
+                && /^target: \S+\s+seq: \d+$/m.test(text)
+                && /^time: .+\s+sender: @\S+/m.test(text)
+                && /^\[Message metadata\]$/m.test(text)
+                && /^\[Message body\]$/m.test(text);
+        case 'history_cursor':
+            return /^\[History cursor\]\noldest_visible_seq: \d+(?:\n|$)/.test(text);
+        case 'recent_summary':
+            return /^\[Recent summary\]\n\d+ (?:earlier )?recent messages? on this exact target (?:were not included above|were omitted above)\. Use (?:bigbang message read --channel "[^"]+" --(?:before|after|around) \d+|read_history\(channel="[^"]+", (?:before|after|around)=\d+\)) if you need them\.(?:\n|$)/.test(text);
+        case 'unread_summary':
+            return /^\[Unread summary\]\n\d+ older unread messages? on this exact target were not included above\. Use (?:bigbang message read --channel "[^"]+" --before \d+|read_history\(channel="[^"]+", before=\d+\)) if you need them\.(?:\n|$)/.test(text);
+        default:
+            return false;
+    }
+}
+export function isPromptContextSectionKind(value) {
+    return typeof value === 'string'
+        && (value === 'active_project'
+            || value === 'workspace_memory_reminder'
+            || value === 'source_handoff_reminder'
+            || value === 'reminder_guidance'
+            || value === 'ui_panel_guidance'
+            || value === 'library_document_guidance'
+            || value === 'library_documents'
+            || value === 'thread_root_message'
+            || value === 'bound_task_dm_thread'
+            || value === 'recent_messages'
+            || value === 'history_cursor'
+            || value === 'recent_summary'
+            || value === 'unread_summary'
+            || value === 'activation_pointer'
+            || value === 'dm_context_snapshot'
+            || value === 'dm_active_task_threads'
+            || value === 'dm_active_task_thread_hint'
+            || value === 'participants'
+            || value === 'bound_task_thread'
+            || value === 'task_board_summary'
+            || value === 'task_board_hint'
+            || value === 'surface_system_status'
+            || value === 'relevant_context_hint'
+            || value === 'handoff_capsule'
+            || value === 'shared_collaboration_capsule'
+            || value === 'conversation_rolling_summary'
+            || value === 'continuity'
+            || value === 'other');
+}

package/dist/web/promptHistorySanitizer.js

@@ -0,0 +1,26 @@
+const LOW_SIGNAL_STATUS_LINE_PATTERNS = [
+    /^\s*\[(?:plan|task)\]\s*$/i,
+    /^\s*\[(?:plan|task)\]\s*(?:plan|task)?\s*updated\s*$/i,
+    /^\s*\[(?:plan|task)\s+updated\]\s*$/i,
+    /^\s*(?:plan|task)\s+updated\s*$/i,
+];
+function isLowSignalStatusLine(line) {
+    return LOW_SIGNAL_STATUS_LINE_PATTERNS.some((pattern) => pattern.test(line.trim()));
+}
+export function sanitizePromptHistoryContent(content, senderType) {
+    const trimmed = content.trim();
+    if (!trimmed)
+        return '';
+    if (senderType === 'user')
+        return trimmed;
+    const cleaned = trimmed
+        .split('\n')
+        .filter((line) => !isLowSignalStatusLine(line))
+        .join('\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+    return cleaned;
+}
+export function hasVisiblePromptHistoryContent(content, senderType) {
+    return sanitizePromptHistoryContent(content, senderType).length > 0;
+}

package/dist/web/promptSlashCommands.js

@@ -0,0 +1,158 @@
+const KNOWN_PROMPT_TEXT_SLASH_COMMAND_EXECUTION_KINDS = {
+    reminder: 'prompt_augment',
+    document: 'prompt_augment',
+    panel: 'prompt_augment',
+    'panel:plan': 'prompt_augment',
+    tool: 'prompt_augment',
+    'tool:plan': 'prompt_augment',
+    rewind: 'local_action',
+};
+export function normalizePromptSlashCommandName(value) {
+    const name = value?.trim().toLowerCase();
+    if (name === 'reminder'
+        || name === 'document'
+        || name === 'panel'
+        || name === 'panel:plan'
+        || name === 'tool'
+        || name === 'tool:plan'
+        || name === 'rewind') {
+        return name;
+    }
+    return null;
+}
+export function isPanelPromptSlashCommandName(value) {
+    const name = normalizePromptSlashCommandName(value);
+    return name === 'panel' || name === 'panel:plan';
+}
+export function isWorkspaceToolPromptSlashCommandName(value) {
+    const name = normalizePromptSlashCommandName(value);
+    return name === 'tool' || name === 'tool:plan';
+}
+export function isLayoutPlanPromptSlashCommandName(value) {
+    const name = normalizePromptSlashCommandName(value);
+    return name === 'panel:plan' || name === 'tool:plan';
+}
+export function normalizePromptSlashCommandInput(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const input = value;
+    const name = normalizePromptSlashCommandName(typeof input.name === 'string' ? input.name : null);
+    const bodyText = typeof input.bodyText === 'string' ? input.bodyText.trim() : '';
+    if (name === 'reminder'
+        || name === 'document'
+        || name === 'panel'
+        || name === 'panel:plan'
+        || name === 'tool'
+        || name === 'tool:plan') {
+        return { name, bodyText };
+    }
+    return null;
+}
+export function parseKnownPromptSlashCommandFromText(text) {
+    const match = text.trim().match(/^\/([A-Za-z0-9:_-]+)(?:\s+([\s\S]*))?$/u);
+    const name = match?.[1]?.trim().toLowerCase();
+    if (!name)
+        return null;
+    const executionKind = KNOWN_PROMPT_TEXT_SLASH_COMMAND_EXECUTION_KINDS[name];
+    if (!executionKind)
+        return null;
+    return {
+        name,
+        bodyText: match?.[2]?.trim() ?? '',
+        executionKind,
+    };
+}
+export function toPromptAugmentSlashCommand(slashCommand) {
+    if (!slashCommand || slashCommand.executionKind !== 'prompt_augment')
+        return null;
+    return {
+        name: slashCommand.name,
+        bodyText: slashCommand.bodyText,
+    };
+}
+export function isPanelToggleCommand(slashCommand) {
+    if (!slashCommand || slashCommand.name !== 'panel')
+        return null;
+    const body = slashCommand.bodyText.trim().toLowerCase();
+    if (body === 'off')
+        return 'off';
+    if (body === 'on')
+        return 'on';
+    return null;
+}
+export function getPromptSlashCommandValidationError({ derivedSlashCommand, requestedSlashCommand, sendAsTask, isPrimaryPrivateChat, allowPanelTask, allowToolTask, allowToolPrompt, toolUnavailableError, }) {
+    if (requestedSlashCommand
+        && (!derivedSlashCommand
+            || derivedSlashCommand.executionKind !== 'prompt_augment'
+            || requestedSlashCommand.name !== derivedSlashCommand.name
+            || requestedSlashCommand.bodyText !== derivedSlashCommand.bodyText)) {
+        return {
+            statusCode: 400,
+            error: 'slashCommand payload must match the leading slash command text',
+        };
+    }
+    if (derivedSlashCommand?.executionKind === 'local_action') {
+        return {
+            statusCode: 409,
+            error: `/${derivedSlashCommand.name} is a local-only slash command and cannot be sent to the server`,
+        };
+    }
+    if (derivedSlashCommand?.name === 'reminder' && !derivedSlashCommand.bodyText) {
+        return {
+            statusCode: 400,
+            error: '/reminder requires reminder instructions after the command',
+        };
+    }
+    if (isPanelPromptSlashCommandName(derivedSlashCommand?.name) && !derivedSlashCommand?.bodyText) {
+        return {
+            statusCode: 400,
+            error: `/${derivedSlashCommand?.name ?? 'panel'} requires UI or panel instructions after the command`,
+        };
+    }
+    if (isWorkspaceToolPromptSlashCommandName(derivedSlashCommand?.name) && !derivedSlashCommand?.bodyText) {
+        return {
+            statusCode: 400,
+            error: `/${derivedSlashCommand?.name ?? 'tool'} requires workspace tool instructions after the command`,
+        };
+    }
+    if (derivedSlashCommand?.executionKind !== 'prompt_augment') {
+        return null;
+    }
+    if (isPanelPromptSlashCommandName(derivedSlashCommand.name)) {
+        if (!allowPanelTask && sendAsTask) {
+            return {
+                statusCode: 409,
+                error: 'Slash command requests cannot be sent as tasks',
+            };
+        }
+        return null;
+    }
+    if (isWorkspaceToolPromptSlashCommandName(derivedSlashCommand.name)) {
+        if (sendAsTask && !allowToolTask) {
+            return {
+                statusCode: 409,
+                error: 'Slash command requests cannot be sent as tasks',
+            };
+        }
+        if (allowToolPrompt === false) {
+            return {
+                statusCode: 409,
+                error: toolUnavailableError?.trim() || '/tool is not available on this surface',
+            };
+        }
+        return null;
+    }
+    if (sendAsTask) {
+        return {
+            statusCode: 409,
+            error: 'Slash command requests cannot be sent as tasks',
+        };
+    }
+    if (!isPrimaryPrivateChat) {
+        return {
+            statusCode: 409,
+            error: `/${derivedSlashCommand.name} is only available in a primary private chat`,
+        };
+    }
+    return null;
+}