markdown-notes-engine 1.0.1 → 1.0.2

package/lib/backend/routes/notes.mjs

@@ -0,0 +1,197 @@
+/**
+ * Notes Routes
+ * Handles note CRUD operations
+ */
+
+import express from 'express';
+const router = express.Router();
+
+// Get file structure
+router.get('/structure', async (req, res) => {
+  try {
+    const { githubClient } = req.notesEngine;
+    const structure = await githubClient.getFileStructure();
+    res.json({ structure });
+  } catch (error) {
+    console.error('Error fetching structure:', error);
+    res.status(500).json({ error: 'Failed to fetch file structure' });
+  }
+});
+
+// Get note content
+router.get('/note', async (req, res) => {
+  try {
+    const { path } = req.query;
+    if (!path) {
+      return res.status(400).json({ error: 'Path is required' });
+    }
+
+    const { githubClient } = req.notesEngine;
+    const file = await githubClient.getFile(path);
+
+    if (!file) {
+      return res.status(404).json({ error: 'Note not found' });
+    }
+
+    res.json(file);
+  } catch (error) {
+    console.error('Error fetching note:', error);
+    res.status(500).json({ error: 'Failed to fetch note' });
+  }
+});
+
+// Save note
+router.post('/note', async (req, res) => {
+  try {
+    let { path, content } = req.body;
+
+    if (!path || content === undefined) {
+      return res.status(400).json({ error: 'Path and content are required' });
+    }
+
+    // Ensure .md extension
+    if (!path.endsWith('.md')) {
+      path += '.md';
+    }
+
+    const { githubClient, options } = req.notesEngine;
+
+    // Get existing file SHA if it exists
+    const existingFile = await githubClient.getFile(path);
+    const sha = existingFile ? existingFile.sha : null;
+
+    // Save the file
+    await githubClient.saveFile(path, content, sha);
+
+    // Auto-update README if enabled
+    if (options.autoUpdateReadme !== false && path !== 'README.md') {
+      try {
+        await updateReadme(githubClient);
+      } catch (error) {
+        console.error('Error updating README:', error);
+        // Don't fail the request if README update fails
+      }
+    }
+
+    res.json({ success: true, path });
+  } catch (error) {
+    console.error('Error saving note:', error);
+    res.status(500).json({ error: 'Failed to save note' });
+  }
+});
+
+// Delete note
+router.delete('/note', async (req, res) => {
+  try {
+    const { path } = req.body;
+
+    if (!path) {
+      return res.status(400).json({ error: 'Path is required' });
+    }
+
+    const { githubClient } = req.notesEngine;
+
+    // Get file SHA
+    const file = await githubClient.getFile(path);
+    if (!file) {
+      return res.status(404).json({ error: 'Note not found' });
+    }
+
+    await githubClient.deleteFile(path, file.sha);
+
+    res.json({ success: true });
+  } catch (error) {
+    console.error('Error deleting note:', error);
+    res.status(500).json({ error: 'Failed to delete note' });
+  }
+});
+
+// Create folder
+router.post('/folder', async (req, res) => {
+  try {
+    const { path } = req.body;
+
+    if (!path) {
+      return res.status(400).json({ error: 'Path is required' });
+    }
+
+    const { githubClient } = req.notesEngine;
+    await githubClient.createFolder(path);
+
+    res.json({ success: true });
+  } catch (error) {
+    console.error('Error creating folder:', error);
+    res.status(500).json({ error: 'Failed to create folder' });
+  }
+});
+
+// Delete folder
+router.delete('/folder', async (req, res) => {
+  try {
+    const { path } = req.body;
+
+    if (!path) {
+      return res.status(400).json({ error: 'Path is required' });
+    }
+
+    const { githubClient } = req.notesEngine;
+    await githubClient.deleteFolder(path);
+
+    res.json({ success: true });
+  } catch (error) {
+    console.error('Error deleting folder:', error);
+    res.status(500).json({ error: 'Failed to delete folder' });
+  }
+});
+
+// Render markdown to HTML
+router.post('/render', async (req, res) => {
+  try {
+    const { markdown } = req.body;
+
+    if (markdown === undefined) {
+      return res.status(400).json({ error: 'Markdown content is required' });
+    }
+
+    const { markdownRenderer } = req.notesEngine;
+    const html = markdownRenderer.render(markdown);
+
+    res.json({ html });
+  } catch (error) {
+    console.error('Error rendering markdown:', error);
+    res.status(500).json({ error: 'Failed to render markdown' });
+  }
+});
+
+/**
+ * Auto-update README with list of notes
+ * @private
+ */
+async function updateReadme(githubClient) {
+  const structure = await githubClient.getFileStructure();
+
+  let readmeContent = '# Notes\n\n';
+  readmeContent += 'This is an auto-generated index of all notes.\n\n';
+
+  const mdFiles = structure
+    .filter(item => item.type === 'file' && item.name.endsWith('.md') && item.name !== 'README.md')
+    .sort((a, b) => a.name.localeCompare(b.name));
+
+  if (mdFiles.length === 0) {
+    readmeContent += '*No notes yet.*\n';
+  } else {
+    mdFiles.forEach(file => {
+      const displayName = file.name.replace('.md', '');
+      readmeContent += `- [${displayName}](${file.path})\n`;
+    });
+  }
+
+  readmeContent += `\n---\n*Last updated: ${new Date().toISOString()}*\n`;
+
+  const existingReadme = await githubClient.getFile('README.md');
+  const sha = existingReadme ? existingReadme.sha : null;
+
+  await githubClient.saveFile('README.md', readmeContent, sha);
+}
+
+export default router;

package/lib/backend/routes/search.mjs

@@ -0,0 +1,28 @@
+/**
+ * Search Routes
+ * Handles note searching
+ */
+
+import express from 'express';
+const router = express.Router();
+
+// Search notes
+router.get('/search', async (req, res) => {
+  try {
+    const { q: query } = req.query;
+
+    if (!query) {
+      return res.status(400).json({ error: 'Query parameter "q" is required' });
+    }
+
+    const { githubClient } = req.notesEngine;
+    const results = await githubClient.searchNotes(query);
+
+    res.json({ results });
+  } catch (error) {
+    console.error('Error searching notes:', error);
+    res.status(500).json({ error: 'Failed to search notes' });
+  }
+});
+
+export default router;

package/lib/backend/routes/upload.mjs

@@ -0,0 +1,122 @@
+/**
+ * Upload Routes
+ * Handles image and video uploads
+ */
+
+import express from 'express';
+import fileUpload from 'express-fileupload';
+const router = express.Router();
+
+// File upload middleware
+router.use(fileUpload());
+
+// Upload image (multipart form)
+router.post('/upload-image', async (req, res) => {
+  try {
+    if (!req.files || !req.files.image) {
+      return res.status(400).json({ error: 'No image file provided' });
+    }
+
+    const imageFile = req.files.image;
+    const folder = req.body.folder || '';
+
+    const { storageClient } = req.notesEngine;
+    const imageUrl = await storageClient.uploadImage(
+      imageFile.data,
+      imageFile.name,
+      folder
+    );
+
+    res.json({ imageUrl });
+  } catch (error) {
+    console.error('Error uploading image:', error);
+    res.status(500).json({ error: 'Failed to upload image' });
+  }
+});
+
+// Upload image (base64)
+router.post('/upload-image-base64', async (req, res) => {
+  try {
+    const { image, filename, folder = '' } = req.body;
+
+    if (!image || !filename) {
+      return res.status(400).json({ error: 'Image data and filename are required' });
+    }
+
+    // Remove data URL prefix if present
+    const base64Data = image.replace(/^data:image\/\w+;base64,/, '');
+    const buffer = Buffer.from(base64Data, 'base64');
+
+    const { storageClient } = req.notesEngine;
+    const imageUrl = await storageClient.uploadImage(buffer, filename, folder);
+
+    res.json({ imageUrl });
+  } catch (error) {
+    console.error('Error uploading image:', error);
+    res.status(500).json({ error: 'Failed to upload image' });
+  }
+});
+
+// Upload video
+router.post('/upload-video', async (req, res) => {
+  try {
+    if (!req.files || !req.files.video) {
+      return res.status(400).json({ error: 'No video file provided' });
+    }
+
+    const videoFile = req.files.video;
+    const folder = req.body.folder || '';
+
+    const { storageClient } = req.notesEngine;
+    const videoUrl = await storageClient.uploadVideo(
+      videoFile.data,
+      videoFile.name,
+      folder
+    );
+
+    res.json({ videoUrl });
+  } catch (error) {
+    console.error('Error uploading video:', error);
+    res.status(500).json({ error: 'Failed to upload video' });
+  }
+});
+
+// Delete image
+router.delete('/image', async (req, res) => {
+  try {
+    const { imageUrl } = req.body;
+
+    if (!imageUrl) {
+      return res.status(400).json({ error: 'Image URL is required' });
+    }
+
+    const { storageClient } = req.notesEngine;
+    await storageClient.deleteFile(imageUrl);
+
+    res.json({ success: true });
+  } catch (error) {
+    console.error('Error deleting image:', error);
+    res.status(500).json({ error: 'Failed to delete image' });
+  }
+});
+
+// Delete video
+router.delete('/video', async (req, res) => {
+  try {
+    const { videoUrl } = req.body;
+
+    if (!videoUrl) {
+      return res.status(400).json({ error: 'Video URL is required' });
+    }
+
+    const { storageClient } = req.notesEngine;
+    await storageClient.deleteFile(videoUrl);
+
+    res.json({ success: true });
+  } catch (error) {
+    console.error('Error deleting video:', error);
+    res.status(500).json({ error: 'Failed to delete video' });
+  }
+});
+
+export default router;

package/lib/backend/storage.mjs

@@ -0,0 +1,119 @@
+/**
+ * Storage Client
+ * Handles file uploads to R2 or S3
+ */
+
+import { S3Client, PutObjectCommand, DeleteObjectCommand } from '@aws-sdk/client-s3';
+
+export class StorageClient {
+  constructor(config) {
+    this.config = config;
+    this.publicUrl = config.publicUrl;
+
+    const s3Config = {
+      region: config.type === 'r2' ? 'auto' : (config.region || 'us-east-1'),
+      credentials: {
+        accessKeyId: config.accessKeyId,
+        secretAccessKey: config.secretAccessKey
+      }
+    };
+
+    // R2-specific endpoint
+    if (config.type === 'r2') {
+      s3Config.endpoint = `https://${config.accountId}.r2.cloudflarestorage.com`;
+    }
+
+    this.s3Client = new S3Client(s3Config);
+    this.bucketName = config.bucketName;
+  }
+
+  /**
+   * Upload an image file
+   * @param {Buffer} fileBuffer - File buffer
+   * @param {string} filename - Original filename
+   * @param {string} [folder=''] - Optional folder path
+   * @returns {Promise<string>} Public URL of uploaded file
+   */
+  async uploadImage(fileBuffer, filename, folder = '') {
+    const timestamp = Date.now();
+    const sanitizedFilename = filename.replace(/[^a-zA-Z0-9.-]/g, '_');
+    const key = folder
+      ? `images/${folder}/${timestamp}-${sanitizedFilename}`
+      : `images/${timestamp}-${sanitizedFilename}`;
+
+    await this.s3Client.send(new PutObjectCommand({
+      Bucket: this.bucketName,
+      Key: key,
+      Body: fileBuffer,
+      ContentType: this._getContentType(filename)
+    }));
+
+    return `${this.publicUrl}/${key}`;
+  }
+
+  /**
+   * Upload a video file
+   * @param {Buffer} fileBuffer - File buffer
+   * @param {string} filename - Original filename
+   * @param {string} [folder=''] - Optional folder path
+   * @returns {Promise<string>} Public URL of uploaded file
+   */
+  async uploadVideo(fileBuffer, filename, folder = '') {
+    const timestamp = Date.now();
+    const sanitizedFilename = filename.replace(/[^a-zA-Z0-9.-]/g, '_');
+    const key = folder
+      ? `videos/${folder}/${timestamp}-${sanitizedFilename}`
+      : `videos/${timestamp}-${sanitizedFilename}`;
+
+    await this.s3Client.send(new PutObjectCommand({
+      Bucket: this.bucketName,
+      Key: key,
+      Body: fileBuffer,
+      ContentType: this._getContentType(filename)
+    }));
+
+    return `${this.publicUrl}/${key}`;
+  }
+
+  /**
+   * Delete a file
+   * @param {string} fileUrl - Public URL of the file
+   * @returns {Promise<void>}
+   */
+  async deleteFile(fileUrl) {
+    // Extract key from URL
+    const key = fileUrl.replace(this.publicUrl + '/', '');
+
+    await this.s3Client.send(new DeleteObjectCommand({
+      Bucket: this.bucketName,
+      Key: key
+    }));
+  }
+
+  /**
+   * Get content type from filename
+   * @private
+   */
+  _getContentType(filename) {
+    const ext = filename.split('.').pop().toLowerCase();
+
+    const contentTypes = {
+      // Images
+      jpg: 'image/jpeg',
+      jpeg: 'image/jpeg',
+      png: 'image/png',
+      gif: 'image/gif',
+      webp: 'image/webp',
+      svg: 'image/svg+xml',
+
+      // Videos
+      mp4: 'video/mp4',
+      webm: 'video/webm',
+      mov: 'video/quicktime',
+      avi: 'video/x-msvideo',
+      mkv: 'video/x-matroska'
+    };
+
+    return contentTypes[ext] || 'application/octet-stream';
+  }
+}

package/lib/frontend/index.mjs

@@ -0,0 +1,15 @@
+/**
+ * Markdown Notes Engine - Frontend Module
+ *
+ * A markdown note-taking editor with GitHub integration
+ */
+
+// Note: This frontend module is browser-based and already supports both module systems.
+// For ES modules in browser, you would import this, but the class itself works the same way.
+// The actual implementation is in index.js and works in both environments.
+
+// Re-export the NotesEditor class for ES module users
+import { NotesEditor } from './index.js';
+
+export { NotesEditor };
+export default NotesEditor;

package/lib/index.mjs

@@ -0,0 +1,17 @@
+/**
+ * Markdown Notes Engine
+ *
+ * A complete markdown note-taking solution with GitHub integration
+ * and media hosting (R2/S3).
+ *
+ * @module markdown-notes-engine
+ */
+
+// Backend exports
+export { createNotesRouter } from './backend/index.mjs';
+export { GitHubClient } from './backend/github.mjs';
+export { StorageClient } from './backend/storage.mjs';
+export { MarkdownRenderer } from './backend/markdown.mjs';
+
+// Frontend exports
+export { NotesEditor } from './frontend/index.mjs';

package/package.json

@@ -1,8 +1,35 @@
 {
   "name": "markdown-notes-engine",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "A complete markdown note-taking engine with GitHub integration and media hosting (R2/S3)",
   "main": "lib/index.js",
+  "module": "lib/index.mjs",
+  "exports": {
+    ".": {
+      "import": "./lib/index.mjs",
+      "require": "./lib/index.js"
+    },
+    "./backend": {
+      "import": "./lib/backend/index.mjs",
+      "require": "./lib/backend/index.js"
+    },
+    "./backend/github": {
+      "import": "./lib/backend/github.mjs",
+      "require": "./lib/backend/github.js"
+    },
+    "./backend/storage": {
+      "import": "./lib/backend/storage.mjs",
+      "require": "./lib/backend/storage.js"
+    },
+    "./backend/markdown": {
+      "import": "./lib/backend/markdown.mjs",
+      "require": "./lib/backend/markdown.js"
+    },
+    "./frontend": {
+      "import": "./lib/frontend/index.mjs",
+      "require": "./lib/frontend/index.js"
+    }
+  },
   "scripts": {
     "start": "node server.js",
     "dev": "nodemon server.js",
@@ -25,7 +52,8 @@
     "url": "https://github.com/cdthomp1/markdown-notes-engine"
   },
   "files": [
-    "lib/**/*",
+    "lib/**/*.js",
+    "lib/**/*.mjs",
     "README.md",
     "LICENSE"
   ],