mrmd-server 0.1.0 → 0.1.2

package/src/api/notebook.js

@@ -0,0 +1,290 @@
+/**
+ * Notebook (Jupyter) API routes
+ *
+ * Mirrors electronAPI.notebook.*
+ */
+
+import { Router } from 'express';
+import { spawn } from 'child_process';
+import path from 'path';
+import fs from 'fs/promises';
+
+// Active sync processes: ipynbPath -> { process, shadowPath, syncPort }
+const syncProcesses = new Map();
+
+/**
+ * Create notebook routes
+ * @param {import('../server.js').ServerContext} ctx
+ */
+export function createNotebookRoutes(ctx) {
+  const router = Router();
+
+  /**
+   * POST /api/notebook/convert
+   * Convert a Jupyter notebook to markdown (deletes the .ipynb file)
+   * Mirrors: electronAPI.notebook.convert(ipynbPath)
+   */
+  router.post('/convert', async (req, res) => {
+    try {
+      const { ipynbPath } = req.body;
+      if (!ipynbPath) {
+        return res.status(400).json({ error: 'ipynbPath required' });
+      }
+
+      const fullPath = path.resolve(ctx.projectDir, ipynbPath);
+
+      // Verify file exists and is .ipynb
+      try {
+        await fs.access(fullPath);
+      } catch {
+        return res.status(404).json({ success: false, error: 'File not found' });
+      }
+
+      if (!fullPath.endsWith('.ipynb')) {
+        return res.status(400).json({ success: false, error: 'File must be a .ipynb file' });
+      }
+
+      // Read notebook
+      const content = await fs.readFile(fullPath, 'utf-8');
+      const notebook = JSON.parse(content);
+
+      // Convert to markdown
+      const markdown = convertNotebookToMarkdown(notebook);
+
+      // Write markdown file
+      const mdPath = fullPath.replace(/\.ipynb$/, '.md');
+      await fs.writeFile(mdPath, markdown, 'utf-8');
+
+      // Delete original .ipynb
+      await fs.unlink(fullPath);
+
+      res.json({
+        success: true,
+        mdPath: path.relative(ctx.projectDir, mdPath),
+      });
+    } catch (err) {
+      console.error('[notebook:convert]', err);
+      res.status(500).json({ success: false, error: err.message });
+    }
+  });
+
+  /**
+   * POST /api/notebook/start-sync
+   * Start syncing a notebook (creates shadow .md in .mrmd folder)
+   * Mirrors: electronAPI.notebook.startSync(ipynbPath)
+   */
+  router.post('/start-sync', async (req, res) => {
+    try {
+      const { ipynbPath } = req.body;
+      if (!ipynbPath) {
+        return res.status(400).json({ error: 'ipynbPath required' });
+      }
+
+      const fullPath = path.resolve(ctx.projectDir, ipynbPath);
+
+      // Check if already syncing
+      if (syncProcesses.has(fullPath)) {
+        const existing = syncProcesses.get(fullPath);
+        return res.json({
+          success: true,
+          shadowPath: existing.shadowPath,
+          syncPort: existing.syncPort,
+          reused: true,
+        });
+      }
+
+      // Verify file exists
+      try {
+        await fs.access(fullPath);
+      } catch {
+        return res.status(404).json({ success: false, error: 'File not found' });
+      }
+
+      // Create .mrmd directory if needed
+      const mrmdDir = path.join(path.dirname(fullPath), '.mrmd');
+      await fs.mkdir(mrmdDir, { recursive: true });
+
+      // Create shadow markdown file
+      const baseName = path.basename(fullPath, '.ipynb');
+      const shadowPath = path.join(mrmdDir, `${baseName}.shadow.md`);
+
+      // Read and convert notebook
+      const content = await fs.readFile(fullPath, 'utf-8');
+      const notebook = JSON.parse(content);
+      const markdown = convertNotebookToMarkdown(notebook);
+      await fs.writeFile(shadowPath, markdown, 'utf-8');
+
+      // Find mrmd-jupyter-bridge
+      const bridgePaths = [
+        path.join(ctx.projectDir, '../mrmd-jupyter-bridge'),
+        path.join(process.cwd(), '../mrmd-jupyter-bridge'),
+        path.join(process.cwd(), 'mrmd-jupyter-bridge'),
+      ];
+
+      let bridgePath = null;
+      for (const p of bridgePaths) {
+        try {
+          await fs.access(path.join(p, 'package.json'));
+          bridgePath = p;
+          break;
+        } catch {}
+      }
+
+      let syncPort = null;
+      let proc = null;
+
+      if (bridgePath) {
+        // Start sync process
+        syncPort = 4450 + syncProcesses.size;
+
+        proc = spawn('node', [
+          path.join(bridgePath, 'src', 'sync.js'),
+          '--notebook', fullPath,
+          '--shadow', shadowPath,
+          '--port', syncPort.toString(),
+        ], {
+          cwd: path.dirname(fullPath),
+          stdio: ['pipe', 'pipe', 'pipe'],
+        });
+
+        proc.on('exit', () => {
+          syncProcesses.delete(fullPath);
+        });
+      }
+
+      syncProcesses.set(fullPath, {
+        process: proc,
+        shadowPath: path.relative(ctx.projectDir, shadowPath),
+        syncPort,
+      });
+
+      res.json({
+        success: true,
+        shadowPath: path.relative(ctx.projectDir, shadowPath),
+        syncPort,
+      });
+    } catch (err) {
+      console.error('[notebook:startSync]', err);
+      res.status(500).json({ success: false, error: err.message });
+    }
+  });
+
+  /**
+   * POST /api/notebook/stop-sync
+   * Stop syncing a notebook
+   * Mirrors: electronAPI.notebook.stopSync(ipynbPath)
+   */
+  router.post('/stop-sync', async (req, res) => {
+    try {
+      const { ipynbPath } = req.body;
+      if (!ipynbPath) {
+        return res.status(400).json({ error: 'ipynbPath required' });
+      }
+
+      const fullPath = path.resolve(ctx.projectDir, ipynbPath);
+      const sync = syncProcesses.get(fullPath);
+
+      if (sync) {
+        if (sync.process && !sync.process.killed) {
+          sync.process.kill();
+        }
+        syncProcesses.delete(fullPath);
+      }
+
+      res.json({ success: true });
+    } catch (err) {
+      console.error('[notebook:stopSync]', err);
+      res.status(500).json({ success: false, error: err.message });
+    }
+  });
+
+  return router;
+}
+
+/**
+ * Convert Jupyter notebook to markdown
+ */
+function convertNotebookToMarkdown(notebook) {
+  const cells = notebook.cells || [];
+  const lines = [];
+
+  // Add frontmatter if notebook has metadata
+  if (notebook.metadata?.kernelspec?.language) {
+    lines.push('---');
+    lines.push(`language: ${notebook.metadata.kernelspec.language}`);
+    if (notebook.metadata.kernelspec.display_name) {
+      lines.push(`kernel: ${notebook.metadata.kernelspec.display_name}`);
+    }
+    lines.push('---');
+    lines.push('');
+  }
+
+  for (const cell of cells) {
+    const source = Array.isArray(cell.source)
+      ? cell.source.join('')
+      : cell.source || '';
+
+    if (cell.cell_type === 'markdown') {
+      lines.push(source.trim());
+      lines.push('');
+    } else if (cell.cell_type === 'code') {
+      // Determine language
+      const lang = notebook.metadata?.kernelspec?.language || 'python';
+
+      lines.push('```' + lang);
+      lines.push(source.trim());
+      lines.push('```');
+      lines.push('');
+
+      // Add outputs if present
+      if (cell.outputs && cell.outputs.length > 0) {
+        for (const output of cell.outputs) {
+          if (output.output_type === 'stream') {
+            const text = Array.isArray(output.text)
+              ? output.text.join('')
+              : output.text || '';
+            if (text.trim()) {
+              lines.push('```output');
+              lines.push(text.trim());
+              lines.push('```');
+              lines.push('');
+            }
+          } else if (output.output_type === 'execute_result' || output.output_type === 'display_data') {
+            const data = output.data || {};
+            if (data['text/plain']) {
+              const text = Array.isArray(data['text/plain'])
+                ? data['text/plain'].join('')
+                : data['text/plain'];
+              lines.push('```output');
+              lines.push(text.trim());
+              lines.push('```');
+              lines.push('');
+            }
+            // Handle images
+            if (data['image/png']) {
+              lines.push(`![output](data:image/png;base64,${data['image/png']})`);
+              lines.push('');
+            }
+          } else if (output.output_type === 'error') {
+            const traceback = output.traceback || [];
+            // Strip ANSI codes
+            const cleanTraceback = traceback
+              .map(line => line.replace(/\x1b\[[0-9;]*m/g, ''))
+              .join('\n');
+            lines.push('```error');
+            lines.push(cleanTraceback.trim());
+            lines.push('```');
+            lines.push('');
+          }
+        }
+      }
+    } else if (cell.cell_type === 'raw') {
+      lines.push('```');
+      lines.push(source.trim());
+      lines.push('```');
+      lines.push('');
+    }
+  }
+
+  return lines.join('\n');
+}

package/src/api/project.js

@@ -1,13 +1,38 @@
 /**
  * Project API routes
  *
- * Mirrors electronAPI.project.*
+ * Mirrors electronAPI.project.* using ProjectService from mrmd-electron
+ * and dynamic sync server management.
  */
 
 import { Router } from 'express';
 import path from 'path';
 import fs from 'fs/promises';
+import { existsSync, readFileSync } from 'fs';
 import { watch } from 'chokidar';
+import { Project } from 'mrmd-project';
+
+/**
+ * Detect project from a file path
+ * Returns { root, config } or null if not in a project
+ */
+function detectProject(filePath) {
+  // Use mrmd-project's findRoot to locate project root
+  const root = Project.findRoot(filePath, (dir) => existsSync(path.join(dir, 'mrmd.md')));
+
+  if (!root) return null;
+
+  // Read and parse mrmd.md config
+  try {
+    const mrmdPath = path.join(root, 'mrmd.md');
+    const content = readFileSync(mrmdPath, 'utf8');
+    const config = Project.parseConfig(content);
+    return { root, config };
+  } catch (e) {
+    // mrmd.md exists but couldn't be read/parsed
+    return { root, config: {} };
+  }
+}
 
 /**
  * Create project routes
@@ -15,11 +40,14 @@ import { watch } from 'chokidar';
  */
 export function createProjectRoutes(ctx) {
   const router = Router();
+  const { projectService, acquireSyncServer, releaseSyncServer, getSyncServer, listSyncServers } = ctx;
 
   /**
    * GET /api/project?path=...
    * Get project info for a file path
    * Mirrors: electronAPI.project.get(filePath)
+   *
+   * Enhanced: Now uses mrmd-project for detection and starts sync server dynamically
    */
   router.get('/', async (req, res) => {
     try {
@@ -28,14 +56,91 @@ export function createProjectRoutes(ctx) {
         return res.status(400).json({ error: 'path query parameter required' });
       }
 
-      const projectInfo = await getProjectInfo(filePath, ctx.projectDir);
-      res.json(projectInfo);
+      // Detect project from file path
+      const resolvedPath = path.isAbsolute(filePath) ? filePath : path.resolve(ctx.projectDir || process.cwd(), filePath);
+      const detected = detectProject(resolvedPath);
+
+      if (detected) {
+        // Get or start sync server for this project
+        let syncInfo = null;
+        try {
+          syncInfo = await acquireSyncServer(detected.root);
+        } catch (e) {
+          console.warn('[project] Could not start sync server:', e.message);
+        }
+
+        // Build nav tree
+        const navTree = await buildNavTree(detected.root);
+
+        res.json({
+          root: detected.root,
+          config: detected.config,
+          navTree,
+          files: flattenNavTree(navTree, detected.root),
+          currentFile: resolvedPath,
+          syncPort: syncInfo?.port || null,
+        });
+      } else {
+        // No project detected, use fallback
+        const projectInfo = await getProjectInfo(filePath, ctx.projectDir || process.cwd());
+        res.json(projectInfo);
+      }
     } catch (err) {
       console.error('[project:get]', err);
       res.status(500).json({ error: err.message });
     }
   });
 
+  /**
+   * GET /api/project/sync
+   * List all active sync servers
+   */
+  router.get('/sync', async (req, res) => {
+    try {
+      const servers = listSyncServers();
+      res.json(servers);
+    } catch (err) {
+      console.error('[project:sync]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * POST /api/project/sync/acquire
+   * Acquire sync server for a project directory
+   */
+  router.post('/sync/acquire', async (req, res) => {
+    try {
+      const { projectDir } = req.body;
+      if (!projectDir) {
+        return res.status(400).json({ error: 'projectDir required' });
+      }
+      const server = await acquireSyncServer(projectDir);
+      res.json({ port: server.port, dir: server.dir, refCount: server.refCount });
+    } catch (err) {
+      console.error('[project:sync/acquire]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * POST /api/project/sync/release
+   * Release sync server for a project directory
+   */
+  router.post('/sync/release', async (req, res) => {
+    try {
+      const { projectDir } = req.body;
+      if (!projectDir) {
+        return res.status(400).json({ error: 'projectDir required' });
+      }
+      releaseSyncServer(projectDir);
+      res.json({ success: true });
+    } catch (err) {
+      console.error('[project:sync/release]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
   /**
    * POST /api/project
    * Create a new mrmd project
@@ -198,28 +303,89 @@ async function getProjectInfo(filePath, defaultRoot) {
   // Build nav tree
   const navTree = await buildNavTree(projectRoot);
 
+  // Collect all files from nav tree (flattened)
+  const files = flattenNavTree(navTree, projectRoot);
+
   return {
     root: projectRoot,
     config: mrmdConfig,
     navTree,
+    files,
     currentFile: resolvedPath,
   };
 }
 
 /**
- * Parse mrmd.md config (frontmatter)
+ * Flatten nav tree to list of file paths
+ */
+function flattenNavTree(nodes, projectRoot) {
+  const files = [];
+  for (const node of nodes) {
+    if (!node.isFolder) {
+      files.push(path.join(projectRoot, node.path));
+    } else if (node.children) {
+      files.push(...flattenNavTree(node.children, projectRoot));
+    }
+  }
+  return files;
+}
+
+/**
+ * Parse mrmd.md config (from yaml config code blocks)
  */
 function parseMrmdConfig(content) {
   const config = { venv: '.venv' };
 
-  // Simple YAML frontmatter parsing
-  const match = content.match(/^---\n([\s\S]*?)\n---/);
-  if (match) {
+  // Find all ```yaml config blocks and merge them
+  const configBlockRegex = /```yaml\s+config\n([\s\S]*?)```/g;
+  let match;
+
+  while ((match = configBlockRegex.exec(content)) !== null) {
     const yaml = match[1];
-    const venvMatch = yaml.match(/venv:\s*(.+)/);
+
+    // Parse name
+    const nameMatch = yaml.match(/^name:\s*["']?([^"'\n]+)["']?/m);
+    if (nameMatch) {
+      config.name = nameMatch[1].trim();
+    }
+
+    // Parse venv (direct or under session.python)
+    const venvMatch = yaml.match(/^\s*venv:\s*["']?([^"'\n]+)["']?/m);
     if (venvMatch) {
       config.venv = venvMatch[1].trim();
     }
+
+    // Parse session config
+    const sessionMatch = yaml.match(/^session:\n([\s\S]*?)(?=^[^\s]|\Z)/m);
+    if (sessionMatch) {
+      config.session = {};
+      const sessionYaml = sessionMatch[1];
+
+      // Parse python session
+      const pythonMatch = sessionYaml.match(/^\s+python:\n([\s\S]*?)(?=^\s+\w+:|\Z)/m);
+      if (pythonMatch) {
+        config.session.python = {};
+        const pyYaml = pythonMatch[1];
+        const pyVenv = pyYaml.match(/venv:\s*["']?([^"'\n]+)["']?/);
+        if (pyVenv) config.session.python.venv = pyVenv[1].trim();
+        const pyCwd = pyYaml.match(/cwd:\s*["']?([^"'\n]+)["']?/);
+        if (pyCwd) config.session.python.cwd = pyCwd[1].trim();
+        const pyName = pyYaml.match(/name:\s*["']?([^"'\n]+)["']?/);
+        if (pyName) config.session.python.name = pyName[1].trim();
+        const pyAutoStart = pyYaml.match(/auto_start:\s*(true|false)/);
+        if (pyAutoStart) config.session.python.auto_start = pyAutoStart[1] === 'true';
+      }
+    }
+  }
+
+  // Also check YAML frontmatter for backwards compatibility
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (fmMatch) {
+    const yaml = fmMatch[1];
+    const venvMatch = yaml.match(/venv:\s*(.+)/);
+    if (venvMatch && !config.venv) {
+      config.venv = venvMatch[1].trim();
+    }
   }
 
   return config;
@@ -258,16 +424,16 @@ async function buildNavTree(projectRoot, relativePath = '') {
       // Only include directories that have .md files (directly or nested)
       if (children.length > 0 || await hasIndexFile(path.join(projectRoot, entryRelPath))) {
         nodes.push({
-          type: 'folder',
-          name: cleanName(entry.name),
+          isFolder: true,
+          title: cleanName(entry.name),
           path: entryRelPath,
           children,
         });
       }
     } else if (entry.name.endsWith('.md') && entry.name !== 'mrmd.md') {
       nodes.push({
-        type: 'file',
-        name: cleanName(entry.name.replace(/\.md$/, '')),
+        isFolder: false,
+        title: cleanName(entry.name.replace(/\.md$/, '')),
         path: entryRelPath,
       });
     }