mrmd-editor 0.7.0 → 0.8.0

package/src/execution.js

@@ -737,6 +737,9 @@ export class ExecutionManager {
     // Emit start event
     this._emit('cellRun', index, cell, execId);
 
+    // Direct execution output write throttling (reduces CRDT churn for progress bars)
+    let clearChunkFlushTimer = null;
+
     try {
       // Prepare output position
       // Re-read content as it may have changed
@@ -815,22 +818,11 @@ export class ExecutionManager {
 
       // Track current output length in document for replacement
       let currentDocOutputLen = 0;
+      const chunkFlushMs = 100;
+      let chunkFlushTimer = null;
+      let latestProcessedOutput = '';
 
-      const onChunk = (chunk, accumulatedRaw, done) => {
-        if (controller.signal.aborted) return;
-
-        // Process through terminal buffer (handles \r, cursor movement, ANSI)
-        buffer.write(chunk);
-
-        // Get processed output with ANSI codes preserved
-        let processedOutput = buffer.toAnsi();
-
-        // Ensure output ends with newline so closing ``` stays on its own line
-        // This is critical for maintaining valid markdown structure
-        if (processedOutput && !processedOutput.endsWith('\n')) {
-          processedOutput += '\n';
-        }
-
+      const applyProcessedOutput = (processedOutput) => {
         // Get current position - prefer finding by execId for robustness
         let currentOutputStart = outputContentStart;
 
@@ -865,6 +857,61 @@ export class ExecutionManager {
         });
 
         currentDocOutputLen = processedOutput.length;
+      };
+
+      const flushChunkOutputNow = () => {
+        if (chunkFlushTimer) {
+          clearTimeout(chunkFlushTimer);
+          chunkFlushTimer = null;
+        }
+        applyProcessedOutput(latestProcessedOutput);
+      };
+
+      clearChunkFlushTimer = () => {
+        if (chunkFlushTimer) {
+          clearTimeout(chunkFlushTimer);
+          chunkFlushTimer = null;
+        }
+      };
+
+      const scheduleChunkOutputFlush = () => {
+        if (chunkFlushMs === 0) {
+          flushChunkOutputNow();
+          return;
+        }
+        if (chunkFlushTimer) return;
+        chunkFlushTimer = setTimeout(() => {
+          chunkFlushTimer = null;
+          applyProcessedOutput(latestProcessedOutput);
+        }, chunkFlushMs);
+      };
+
+      controller.signal.addEventListener('abort', () => {
+        clearChunkFlushTimer?.();
+      }, { once: true });
+
+      const onChunk = (chunk, accumulatedRaw, done) => {
+        if (controller.signal.aborted) return;
+
+        // Process through terminal buffer (handles \r, cursor movement, ANSI)
+        buffer.write(chunk);
+
+        // Get processed output with ANSI codes preserved
+        let processedOutput = buffer.toAnsi();
+
+        // Ensure output ends with newline so closing ``` stays on its own line
+        // This is critical for maintaining valid markdown structure
+        if (processedOutput && !processedOutput.endsWith('\n')) {
+          processedOutput += '\n';
+        }
+
+        latestProcessedOutput = processedOutput;
+
+        if (done) {
+          flushChunkOutputNow();
+        } else {
+          scheduleChunkOutputFlush();
+        }
 
         this._emit('cellOutput', index, chunk, processedOutput, execId);
       };
@@ -883,6 +930,9 @@ export class ExecutionManager {
             return;
           }
 
+          // Flush pending output so prompt context is visible immediately
+          flushChunkOutputNow();
+
           const stdinExecId = execId;
 
           // Wait for any pending output to be written to the document
@@ -1009,6 +1059,9 @@ export class ExecutionManager {
         onAsset,
       });
 
+      // Flush any pending throttled output before final normalization
+      flushChunkOutputNow();
+
       // Final update - find output block by execId for robustness
       content = this.editor.getContent();
       const finalOutputBlock = findOutputBlockByExecId(content, execId);
@@ -1127,6 +1180,7 @@ export class ExecutionManager {
       }
       return execId;
     } finally {
+      clearChunkFlushTimer?.();
       this.running.delete(execId);
       this.buffers.delete(execId);
 

package/src/frontmatter-updater.js

@@ -35,19 +35,17 @@ export function parseFrontmatter(content) {
   }
 
   const rawYaml = content.slice(4, endIdx); // Skip opening ---\n
-  const endOfClosing = endIdx + 4; // Include \n---
-
   try {
     const parsed = yaml.parse(rawYaml) || {};
     return {
       exists: true,
       yaml: parsed,
-      range: { start: 0, end: endOfClosing },
+      range: { start: 0, end: endIdx + 4 },
       raw: rawYaml,
     };
   } catch (e) {
     console.warn('[frontmatter-updater] Failed to parse YAML:', e.message);
-    return { exists: true, yaml: null, range: { start: 0, end: endOfClosing }, raw: rawYaml };
+    return { exists: true, yaml: null, range: { start: 0, end: endIdx + 4 }, raw: rawYaml };
   }
 }
 
@@ -57,8 +55,7 @@ export function parseFrontmatter(content) {
  * @param {object} data - Frontmatter data
  * @returns {string} Complete frontmatter block including --- delimiters
  */
-function buildFrontmatter(data) {
-  // Remove empty/null values
+export function buildFrontmatter(data) {
   const cleaned = cleanObject(data);
 
   if (!cleaned || Object.keys(cleaned).length === 0) {
@@ -67,7 +64,7 @@ function buildFrontmatter(data) {
 
   const yamlStr = yaml.stringify(cleaned, {
     indent: 2,
-    lineWidth: 0, // Don't wrap lines
+    lineWidth: 0,
   }).trimEnd();
 
   return `---\n${yamlStr}\n---`;
@@ -75,12 +72,14 @@ function buildFrontmatter(data) {
 
 /**
  * Recursively remove null, undefined, and empty object values.
+ *
  * @param {any} obj
  * @returns {any}
  */
 function cleanObject(obj) {
   if (obj === null || obj === undefined) return undefined;
-  if (typeof obj !== 'object' || Array.isArray(obj)) return obj;
+  if (Array.isArray(obj)) return obj.map(cloneValue).filter(v => v !== undefined);
+  if (typeof obj !== 'object') return obj;
 
   const result = {};
   for (const [key, value] of Object.entries(obj)) {
@@ -90,6 +89,11 @@ function cleanObject(obj) {
       if (cleaned && Object.keys(cleaned).length > 0) {
         result[key] = cleaned;
       }
+    } else if (Array.isArray(value)) {
+      const cleanedArray = value.map(cloneValue).filter(v => v !== undefined);
+      if (cleanedArray.length > 0) {
+        result[key] = cleanedArray;
+      }
     } else {
       result[key] = value;
     }
@@ -97,88 +101,152 @@ function cleanObject(obj) {
   return Object.keys(result).length > 0 ? result : undefined;
 }
 
+function isPlainObject(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function cloneValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(cloneValue);
+  }
+  if (isPlainObject(value)) {
+    return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, cloneValue(v)]));
+  }
+  return value;
+}
+
+function mergeTemplateWithExisting(templateValue, existingValue) {
+  if (existingValue === undefined || existingValue === null) {
+    return cloneValue(templateValue);
+  }
+
+  if (Array.isArray(existingValue)) {
+    return cloneValue(existingValue);
+  }
+
+  if (isPlainObject(templateValue) && isPlainObject(existingValue)) {
+    const result = {};
+    const keys = new Set([...Object.keys(templateValue), ...Object.keys(existingValue)]);
+    for (const key of keys) {
+      result[key] = mergeTemplateWithExisting(templateValue?.[key], existingValue?.[key]);
+    }
+    return result;
+  }
+
+  return cloneValue(existingValue);
+}
+
+function formatLocalDate(date = new Date()) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  return `${year}-${month}-${day}`;
+}
+
+function createTitleSelection(frontmatterBlock) {
+  const prefix = 'title: ';
+  const start = frontmatterBlock.indexOf(prefix);
+  if (start === -1) return null;
+  const from = start + prefix.length;
+  const lineEnd = frontmatterBlock.indexOf('\n', from);
+  return {
+    from,
+    to: lineEnd === -1 ? from : lineEnd,
+  };
+}
+
 /**
- * Update session configuration in document frontmatter.
+ * Create a scholarly frontmatter template.
  *
- * If frontmatter doesn't exist, creates it.
- * If values match project defaults, omits them (keeps frontmatter clean).
+ * @param {Date} [now]
+ * @returns {object}
+ */
+export function createArticleFrontmatterTemplate(now = new Date()) {
+  return {
+    title: 'Untitled',
+    date: formatLocalDate(now),
+    author: [
+      {
+        name: 'Your Name',
+        id: 'your-id',
+        orcid: '0000-0000-0000-0000',
+        email: 'you@example.com',
+        affiliation: [
+          {
+            name: 'Your Institution',
+            city: 'City',
+            state: 'State',
+            url: 'https://example.org',
+          },
+        ],
+      },
+    ],
+    abstract: 'Write your abstract here.\n',
+    keywords: ['Keyword 1', 'Keyword 2'],
+    license: 'CC BY',
+    copyright: {
+      holder: 'Your Name',
+      year: now.getFullYear(),
+    },
+    citation: {
+      'container-title': 'Journal or Venue',
+      volume: 1,
+      issue: 1,
+      doi: '10.0000/example',
+    },
+    funding: 'Add funding information here.',
+  };
+}
+
+/**
+ * Build a document edit that inserts or augments frontmatter with a template.
+ * Existing values win, while missing keys are added from the template.
  *
- * @param {import('@codemirror/view').EditorView} view - CodeMirror editor view
- * @param {string} language - Runtime language (e.g. 'python', 'bash', 'r', 'julia')
- * @param {SessionConfig} config - Session configuration to set
- * @param {SessionConfig} [projectDefaults] - Defaults from mrmd.md to diff against
+ * @param {string} content - Full document content
+ * @param {object} [templateData] - Template frontmatter data
+ * @returns {{ changes: {from: number, to: number, insert: string}, selection: {from: number, to: number}|null, data: object }|null}
  */
-export function updateFrontmatterSession(view, language, config, projectDefaults = {}) {
-  const doc = view.state.doc;
-  const content = doc.toString();
+export function applyFrontmatterTemplate(content, templateData = createArticleFrontmatterTemplate()) {
   const fm = parseFrontmatter(content);
 
-  // Start with existing frontmatter data or empty object
-  const data = fm.yaml ? { ...fm.yaml } : {};
+  if (fm.exists && !fm.yaml) {
+    return null;
+  }
 
-  // Build session config, omitting values that match project defaults
-  const sessionConfig = {};
+  const merged = fm.exists
+    ? mergeTemplateWithExisting(templateData, fm.yaml || {})
+    : cloneValue(templateData);
 
-  if (config.name !== undefined && config.name !== (projectDefaults.name || 'default')) {
-    sessionConfig.name = config.name;
-  }
-  if (config.venv !== undefined && config.venv !== (projectDefaults.venv || '.venv')) {
-    sessionConfig.venv = config.venv;
-  }
-  if (config.cwd !== undefined && config.cwd !== (projectDefaults.cwd || '.')) {
-    sessionConfig.cwd = config.cwd;
-  }
-  if (config.auto_start !== undefined && config.auto_start !== true) {
-    sessionConfig.auto_start = config.auto_start;
-  }
+  const frontmatterBlock = buildFrontmatter(merged);
+  const selection = createTitleSelection(frontmatterBlock);
 
-  // Update the session section
-  if (Object.keys(sessionConfig).length > 0) {
-    if (!data.session) data.session = {};
-    data.session[language] = {
-      ...(data.session[language] || {}),
-      ...sessionConfig,
+  if (!fm.exists) {
+    return {
+      changes: {
+        from: 0,
+        to: 0,
+        insert: `${frontmatterBlock}${content.length > 0 ? '\n\n' : '\n'}`,
+      },
+      selection,
+      data: merged,
     };
-  } else {
-    // All values match defaults — remove the language key if it exists
-    if (data.session && data.session[language]) {
-      delete data.session[language];
-      if (Object.keys(data.session).length === 0) {
-        delete data.session;
-      }
-    }
   }
 
-  // Build new frontmatter string
-  const newFrontmatter = buildFrontmatter(data);
-
-  // Apply the change to the editor
-  if (fm.exists && fm.range) {
-    // Replace existing frontmatter
-    if (newFrontmatter) {
-      view.dispatch({
-        changes: { from: fm.range.start, to: fm.range.end, insert: newFrontmatter },
-      });
-    } else {
-      // Remove frontmatter entirely (and trailing newline if present)
-      let removeEnd = fm.range.end;
-      if (content[removeEnd] === '\n') removeEnd++;
-      view.dispatch({
-        changes: { from: fm.range.start, to: removeEnd, insert: '' },
-      });
-    }
-  } else if (newFrontmatter) {
-    // Insert new frontmatter at the top
-    view.dispatch({
-      changes: { from: 0, to: 0, insert: newFrontmatter + '\n\n' },
-    });
-  }
+  return {
+    changes: {
+      from: fm.range?.start ?? 0,
+      to: fm.range?.end ?? 0,
+      insert: frontmatterBlock,
+    },
+    selection,
+    data: merged,
+  };
 }
 
 /**
  * Read current session configuration from document frontmatter.
  *
- * @param {string} content - Document content
+ * @param {string} content - Full document content
  * @param {string} language - Runtime language
  * @returns {SessionConfig} Current session config (may be empty object if using defaults)
  */
@@ -208,7 +276,7 @@ export function readFrontmatterSession(content, language) {
  * Get the effective session configuration for a document,
  * merging project defaults with document-level overrides.
  *
- * @param {string} content - Document content
+ * @param {string} content - Full document content
  * @param {string} language - Runtime language
  * @param {SessionConfig} projectDefaults - Defaults from mrmd.md
  * @returns {SessionConfig} Effective configuration
@@ -222,3 +290,65 @@ export function getEffectiveSessionConfig(content, language, projectDefaults = {
     auto_start: docConfig.auto_start ?? projectDefaults.auto_start ?? true,
   };
 }
+
+function setPathValue(target, path, value) {
+  const parts = Array.isArray(path) ? path : String(path).split('.').filter(Boolean);
+  if (!parts.length) return target;
+
+  let obj = target;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const key = parts[i];
+    if (!obj[key] || typeof obj[key] !== 'object' || Array.isArray(obj[key])) {
+      obj[key] = {};
+    }
+    obj = obj[key];
+  }
+
+  const leaf = parts[parts.length - 1];
+  if (value === undefined || value === null || value === '') {
+    delete obj[leaf];
+  } else {
+    obj[leaf] = value;
+  }
+  return target;
+}
+
+export function readFrontmatterValue(content, path, fallback = undefined) {
+  const fm = parseFrontmatter(content);
+  const parts = Array.isArray(path) ? path : String(path).split('.').filter(Boolean);
+  let value = fm.yaml || {};
+  for (const part of parts) {
+    if (value == null || typeof value !== 'object') return fallback;
+    value = value[part];
+  }
+  return value === undefined ? fallback : value;
+}
+
+export function updateFrontmatterField(content, path, value) {
+  const fm = parseFrontmatter(content);
+  if (fm.exists && !fm.yaml) return null;
+
+  const data = fm.exists ? cloneValue(fm.yaml || {}) : {};
+  setPathValue(data, path, value);
+  const frontmatterBlock = buildFrontmatter(data);
+
+  if (!fm.exists) {
+    return {
+      changes: {
+        from: 0,
+        to: 0,
+        insert: `${frontmatterBlock}${content.length > 0 ? '\n\n' : '\n'}`,
+      },
+      data,
+    };
+  }
+
+  return {
+    changes: {
+      from: fm.range?.start ?? 0,
+      to: fm.range?.end ?? 0,
+      insert: frontmatterBlock,
+    },
+    data,
+  };
+}