// Create a temporary div to parse HTML

const tempDiv = document.createElement('div');

tempDiv.innerHTML = html;

// Function to count nesting level (how many ul/ol parents)

function getNestingLevel(node) {

let level = 0;

let parent = node.parentElement;

while (parent) {

if (parent.tagName?.toLowerCase() === 'ul' || parent.tagName?.toLowerCase() === 'ol') {

level++;

}

parent = parent.parentElement;

}

return level;

}

// Function to process a node and convert to plain text

function processNode(node, indent = '') {

let result = '';

if (node.nodeType === Node.TEXT_NODE) {

// Text node - preserve whitespace

const text = node.textContent || '';

return text;

}

if (node.nodeType === Node.ELEMENT_NODE) {

const tagName = node.tagName?.toLowerCase();

if (tagName === 'ul' || tagName === 'ol') {

// List container - process children (don't add extra indent here)

const children = Array.from(node.childNodes);

children.forEach((child) => {

result += processNode(child, indent);

});

} else if (tagName === 'li') {

// List item - add bullet point with proper indentation

const nestingLevel = getNestingLevel(node);

const indentSpaces = ' '.repeat(nestingLevel - 1); // -1 because root level is 0 indent

// Determine bullet type

const isOrdered = node.parentElement?.tagName?.toLowerCase() === 'ol';

let bullet = '• ';

if (isOrdered) {

// Count previous li siblings at same level to get number

const parentList = node.parentElement;

const siblings = Array.from(parentList.children);

const index = siblings.indexOf(node);

bullet = (index + 1) + '. ';

}

// Process children to get text content

const children = Array.from(node.childNodes);

let itemText = '';

let hasNestedList = false;

children.forEach(child => {

if (child.nodeType === Node.ELEMENT_NODE) {

const childTag = child.tagName?.toLowerCase();

if (childTag === 'ul' || childTag === 'ol') {

hasNestedList = true;

// Process nested list with increased indent

itemText += processNode(child, indentSpaces + ' ');

} else {

// Other elements (p, span, etc.)

itemText += processNode(child, '');

}

} else {

itemText += processNode(child, '');

}

});

// Clean up the item text

itemText = itemText.trim();

if (itemText || hasNestedList) {

// If there's a nested list, don't add the bullet on the same line

if (hasNestedList) {

// Add the main item text if it exists

if (itemText && !itemText.includes('•') && !itemText.match(/^\d+\./)) {

result += indentSpaces + bullet + itemText.split('\n')[0] + '\n';

}

// The nested list will be added by processNode

result += itemText;

} else {

result += indentSpaces + bullet + itemText + '\n';

}

}

} else if (tagName === 'p' || tagName === 'div') {

// Paragraph or div - process children and add newline

const children = Array.from(node.childNodes);

let paraText = '';

children.forEach(child => {

paraText += processNode(child, indent);

});

paraText = paraText.trim();

if (paraText) {

result += indent + paraText + '\n';

}

} else if (tagName === 'br') {

// Line break

result += '\n';

} else {

// Other elements - process children

const children = Array.from(node.childNodes);

children.forEach(child => {

result += processNode(child, indent);

});

}

}

return result;

}

// Process all nodes

let text = '';

const children = Array.from(tempDiv.childNodes);

children.forEach(child => {

text += processNode(child);

});

// Clean up extra newlines but preserve structure

return text.replace(/\n{3,}/g, '\n\n').trim();

const formatOptions = [

'audio/webm;codecs=opus',

'audio/webm',

'audio/ogg;codecs=opus',

'audio/mp4',

'audio/wav'

];

for (const format of formatOptions) {

if (MediaRecorder.isTypeSupported(format)) {

return format;

}

}

return null; // Fallback to browser default

// Check blob size - too small might be invalid

if (audioBlob.size < 100) {

console.log('Skipping too small audio chunk:', audioBlob.size, 'bytes');

return null;

}

try {

// Send audio blob directly as binary to backend

const response = await fetch('/api/transcribe', {

method: 'POST',

body: audioBlob

// Don't set Content-Type - let browser set it automatically

});

if (!response.ok) {

const error = await response.json();

if (response.status === 401 || response.status === 500) {

throw new Error(error.message || 'Invalid Deepgram API key. Please check your configuration.');

} else if (response.status === 400) {

console.warn('Deepgram rejected audio chunk (possibly incomplete):', error.message);

return null; // Don't throw, just skip this chunk

}

throw new Error(error.message || `Transcription error: ${response.status}`);

}

const result = await response.json();

// Extract transcript from Deepgram response

if (result.results && result.results.channels && result.results.channels.length > 0) {

const channel = result.results.channels[0];

if (channel.alternatives && channel.alternatives.length > 0) {

const transcript = channel.alternatives[0].transcript;

if (transcript && transcript.trim()) {

return transcript.trim();

}

}

}

return null;

} catch (error) {

console.error('Transcription error:', error);

throw error;

}

const currentText = notesInput.value;

const cursorPos = notesInput.selectionStart;

// Add space before if there's existing text and it doesn't end with space/newline

const prefix = currentText && !currentText.match(/[\s\n]$/) ? ' ' : '';

// Insert transcript at cursor position or append to end

const newText = currentText.substring(0, cursorPos) + prefix + transcript + currentText.substring(cursorPos);

notesInput.value = newText;

// Move cursor to end of inserted text

const newCursorPos = cursorPos + prefix.length + transcript.length;

notesInput.selectionStart = notesInput.selectionEnd = newCursorPos;

// Trigger input event

notesInput.dispatchEvent(new Event('input'));

try {

stopAllRecordings(); // Stop any active recording

// Use selected audio device if available

const constraints = { audio: true };

if (selectedAudioDeviceId) {

constraints.audio = { deviceId: { exact: selectedAudioDeviceId } };

}

audioStream = await navigator.mediaDevices.getUserMedia(constraints);

recordingMode = 'mic';

await setupRecording();

} catch (error) {

console.error('Error starting microphone recording:', error);

showError(`Failed to start microphone recording: ${error.message}`);

isRecording = false;

recordBtn.classList.remove('recording');

}

try {

// Create audio context

audioContext = new (window.AudioContext || window.webkitAudioContext)();

// Create source nodes from both streams

const micSource = audioContext.createMediaStreamSource(micStream);

const tabSource = audioContext.createMediaStreamSource(tabStream);

// Create a destination node to mix both streams

const destination = audioContext.createMediaStreamDestination();

// Connect both sources to the destination (mixing)

micSource.connect(destination);

tabSource.connect(destination);

// Return the mixed stream

return destination.stream;

} catch (error) {

console.error('Error combining audio streams:', error);

throw error;

}

try {

stopAllRecordings(); // Stop any active recording

// Use selected audio device if available

const micConstraints = { audio: true };

if (selectedAudioDeviceId) {

micConstraints.audio = { deviceId: { exact: selectedAudioDeviceId } };

}

const [mic, tab] = await Promise.all([

navigator.mediaDevices.getUserMedia(micConstraints),

navigator.mediaDevices.getDisplayMedia({

video: true,

audio: {

echoCancellation: false,

noiseSuppression: false,

autoGainControl: false,

suppressLocalAudioPlayback: false

}

})

]);

// Check if tab audio track exists

const tabAudioTracks = tab.getAudioTracks();

if (tabAudioTracks.length === 0) {

// User didn't share audio

mic.getTracks().forEach(track => track.stop());

tab.getTracks().forEach(track => track.stop());

showError('No audio track detected in tab. Please make sure to check "Share tab audio" when selecting a tab.');

isRecordingBoth = false;

recordBothBtn.classList.remove('recording');

return;

}

// Stop video track if present (we only need audio)

const videoTracks = tab.getVideoTracks();

videoTracks.forEach(track => track.stop());

// Store individual streams for cleanup

micStream = mic;

tabStream = tab;

// Combine the two audio streams

audioStream = await combineAudioStreams(mic, tab);

recordingMode = 'both';

await setupRecording();

// Handle user stopping sharing from browser UI

tabAudioTracks[0].addEventListener('ended', () => {

if (isRecordingBoth) {

stopBothRecording();

}

});

} catch (error) {

console.error('Error starting both recording:', error);

if (error.name === 'NotAllowedError') {

showError('Permission denied. Please allow microphone and tab sharing to record audio.');

} else {

showError(`Failed to start recording: ${error.message}`);

}

isRecordingBoth = false;

recordBothBtn.classList.remove('recording');

// Clean up streams if they were created

if (micStream) {

micStream.getTracks().forEach(track => track.stop());

micStream = null;

}

if (tabStream) {

tabStream.getTracks().forEach(track => track.stop());

tabStream = null;

}

if (audioContext) {

audioContext.close();

audioContext = null;

}

}

try {

// Request tab audio capture

audioStream = await navigator.mediaDevices.getDisplayMedia({

video: true,

audio: {

echoCancellation: false,

noiseSuppression: false,

autoGainControl: false,

suppressLocalAudioPlayback: false

}

});

// Check if audio track exists

const audioTracks = audioStream.getAudioTracks();

if (audioTracks.length === 0) {

// User didn't share audio

audioStream.getTracks().forEach(track => track.stop());

showError('No audio track detected. Please make sure to check "Share tab audio" when selecting a tab.');

isRecordingTab = false;

recordTabBtn.classList.remove('recording');

return;

}

// Stop video track if present (we only need audio)

const videoTracks = audioStream.getVideoTracks();

videoTracks.forEach(track => track.stop());

recordingMode = 'tab';

await setupRecording();

// Handle user stopping sharing from browser UI

audioTracks[0].addEventListener('ended', () => {

if (isRecordingTab) {

stopTabRecording();

}

});

} catch (error) {

console.error('Error starting tab recording:', error);

if (error.name === 'NotAllowedError') {

showError('Permission denied. Please allow tab sharing to record audio.');

} else {

showError(`Failed to start tab recording: ${error.message}`);

}

isRecordingTab = false;

recordTabBtn.classList.remove('recording');

}

try {

// Select best audio format

selectedFormat = selectBestAudioFormat();

if (!selectedFormat) {

throw new Error('No supported audio format found');

}

console.log('Using audio format:', selectedFormat);

// Create MediaRecorder

mediaRecorder = new MediaRecorder(audioStream, {

mimeType: selectedFormat,

audioBitsPerSecond: 128000

});

segmentChunks = [];

// Handle data available

mediaRecorder.ondataavailable = (event) => {

if (event.data && event.data.size > 0) {

segmentChunks.push(event.data);

}

};

// Handle recording stop

mediaRecorder.onstop = async () => {

if (segmentChunks.length > 0) {

const audioBlob = new Blob(segmentChunks, {

type: selectedFormat || 'audio/webm'

});

// Only send if large enough (reduced threshold for live transcription)

if (audioBlob.size > 8000) {

try {

const transcription = await transcribeWithDeepgram(audioBlob);

if (transcription && transcription.trim()) {

addTranscription(transcription);

}

} catch (error) {

console.error('Transcription error:', error);

// Don't show error to user for individual chunk failures

}

}

segmentChunks = []; // Clear for next segment

// Restart if still recording (reduced delay for live transcription)

const stillRecording = (recordingMode === 'mic' && isRecording) ||

(recordingMode === 'tab' && isRecordingTab) ||

(recordingMode === 'both' && isRecordingBoth);

if (stillRecording && mediaRecorder && mediaRecorder.state === 'inactive') {

setTimeout(() => {

const stillRecordingCheck = (recordingMode === 'mic' && isRecording) ||

(recordingMode === 'tab' && isRecordingTab) ||

(recordingMode === 'both' && isRecordingBoth);

if (stillRecordingCheck && mediaRecorder) {

mediaRecorder.start();

// Stop after 2 seconds for live transcription

setTimeout(() => {

if (mediaRecorder && mediaRecorder.state === 'recording') {

mediaRecorder.stop();

}

}, 2000);

}

}, 200); // Reduced delay between segments

}

}

};

// Start first segment (use 2 seconds for live transcription)

mediaRecorder.start();

setTimeout(() => {

if (mediaRecorder && mediaRecorder.state === 'recording') {

mediaRecorder.stop();

}

}, 2000); // Reduced to 2 seconds for live transcription

if (recordingMode === 'mic') {

isRecording = true;

recordBtn.classList.add('recording');

} else if (recordingMode === 'tab') {

isRecordingTab = true;

recordTabBtn.classList.add('recording');

} else if (recordingMode === 'both') {

isRecordingBoth = true;

recordBothBtn.classList.add('recording');

}

} catch (error) {

console.error('Error setting up recording:', error);

showError(`Failed to setup recording: ${error.message}`);

if (recordingMode === 'mic') {

isRecording = false;

recordBtn.classList.remove('recording');

} else if (recordingMode === 'tab') {

isRecordingTab = false;

recordTabBtn.classList.remove('recording');

} else if (recordingMode === 'both') {

isRecordingBoth = false;

recordBothBtn.classList.remove('recording');

}

if (audioStream) {

audioStream.getTracks().forEach(track => track.stop());

audioStream = null;

}

if (micStream) {

micStream.getTracks().forEach(track => track.stop());

micStream = null;

}

if (tabStream) {

tabStream.getTracks().forEach(track => track.stop());

tabStream = null;

}

if (audioContext) {

audioContext.close();

audioContext = null;

}

}

isRecording = false;

recordBtn.classList.remove('recording');

if (mediaRecorder && mediaRecorder.state !== 'inactive') {

mediaRecorder.stop();

}

if (audioStream) {

audioStream.getTracks().forEach(track => track.stop());

audioStream = null;

}

mediaRecorder = null;

segmentChunks = [];

isRecordingTab = false;

recordTabBtn.classList.remove('recording');

if (mediaRecorder && mediaRecorder.state !== 'inactive') {

mediaRecorder.stop();

}

if (audioStream) {

audioStream.getTracks().forEach(track => track.stop());

audioStream = null;

}

mediaRecorder = null;

segmentChunks = [];

isRecordingBoth = false;

recordBothBtn.classList.remove('recording');

if (mediaRecorder && mediaRecorder.state !== 'inactive') {

mediaRecorder.stop();

}

// Stop all streams

if (micStream) {

micStream.getTracks().forEach(track => track.stop());

micStream = null;

}

if (tabStream) {

tabStream.getTracks().forEach(track => track.stop());

tabStream = null;

}

if (audioStream) {

audioStream.getTracks().forEach(track => track.stop());

audioStream = null;

}

// Close audio context

if (audioContext) {

audioContext.close();

audioContext = null;

}

mediaRecorder = null;

segmentChunks = [];

if (mediaRecorder && mediaRecorder.state !== 'inactive') {

mediaRecorder.stop();

}

if (audioStream) {

audioStream.getTracks().forEach(track => track.stop());

audioStream = null;

}

if (micStream) {

micStream.getTracks().forEach(track => track.stop());

micStream = null;

}

if (tabStream) {

tabStream.getTracks().forEach(track => track.stop());

tabStream = null;

}

if (audioContext) {

audioContext.close();

audioContext = null;

}

isRecording = false;

isRecordingTab = false;

isRecordingBoth = false;

recordBtn.classList.remove('recording');

recordTabBtn.classList.remove('recording');

recordBothBtn.classList.remove('recording');

mediaRecorder = null;

segmentChunks = [];