@romansmirnov/doku 1.0.0

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@romansmirnov/doku",
+  "version": "1.0.0",
+  "description": "Personal documentation system with Markdown storage and WYSIWYG editing",
+  "main": "server/index.js",
+  "bin": {
+    "doku": "bin/doku.js"
+  },
+  "files": [
+    "bin/",
+    "server/",
+    "dist/",
+    "icons/icons/",
+    "client/src/lib/",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "dev": "node server/index.js",
+    "build": "vite build",
+    "preview": "vite preview",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": ["documentation", "markdown", "wiki", "notes", "knowledge-base"],
+  "author": "Roman Smirnov",
+  "license": "MIT",
+  "type": "commonjs",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/romasm/Doku.git"
+  },
+  "dependencies": {
+    "chokidar": "^5.0.0",
+    "cors": "^2.8.6",
+    "express": "^5.2.1",
+    "glob": "^13.0.6",
+    "multer": "^2.1.1"
+  },
+  "devDependencies": {
+    "@blocknote/core": "^0.47.3",
+    "@blocknote/mantine": "^0.47.3",
+    "@blocknote/react": "^0.47.3",
+    "@mantine/core": "^8.3.18",
+    "@mantine/hooks": "^8.3.18",
+    "@vitejs/plugin-react": "^6.0.1",
+    "motion": "^12.38.0",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "react-router-dom": "^7.14.0",
+    "vite": "^8.0.3"
+  }
+}

package/server/api.js

@@ -0,0 +1,313 @@
+const express = require('express');
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const multer = require('multer');
+const search = require('./search');
+const config = require('./config');
+const { parseFrontmatter, extractTitle, formatName } = require('./frontmatter');
+
+const router = express.Router();
+const DOCS_DIR = config.docsPath;
+
+// GET /api/config — public config for frontend
+router.get('/config', (req, res) => {
+  res.json({ projectName: config.projectName });
+});
+
+// Assets directory for uploaded images
+const ASSETS_DIR = path.join(DOCS_DIR, 'assets');
+if (!fs.existsSync(ASSETS_DIR)) {
+  fs.mkdirSync(ASSETS_DIR, { recursive: true });
+}
+
+// Serve assets statically
+router.use('/assets', express.static(ASSETS_DIR));
+
+// Image upload
+const upload = multer({
+  storage: multer.diskStorage({
+    destination: (req, file, cb) => cb(null, ASSETS_DIR),
+    filename: (req, file, cb) => {
+      const ext = path.extname(file.originalname).toLowerCase();
+      const id = crypto.randomBytes(8).toString('hex');
+      cb(null, `${id}${ext}`);
+    },
+  }),
+  fileFilter: (req, file, cb) => {
+    const allowed = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg', '.bmp'];
+    const ext = path.extname(file.originalname).toLowerCase();
+    cb(null, allowed.includes(ext));
+  },
+  limits: { fileSize: 10 * 1024 * 1024 }, // 10MB
+});
+
+router.post('/upload', upload.single('image'), (req, res) => {
+  if (!req.file) {
+    return res.status(400).json({ error: 'No valid image file' });
+  }
+  const url = `/api/assets/${req.file.filename}`;
+  res.json({ url, filename: req.file.filename });
+});
+
+// Express 5 returns wildcard params as arrays — join them back into a path string
+function getDocPath(params) {
+  const p = params.docPath;
+  return Array.isArray(p) ? p.join('/') : p;
+}
+
+// Ensure docs directory exists
+if (!fs.existsSync(DOCS_DIR)) {
+  fs.mkdirSync(DOCS_DIR, { recursive: true });
+}
+
+// Read frontmatter + title from a .md file
+function getFileMeta(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const { frontmatter, body } = parseFrontmatter(content);
+    const title = extractTitle(body);
+    return { ordering: frontmatter.ordering, title };
+  } catch {
+    return { ordering: undefined, title: null };
+  }
+}
+
+// Build the file tree. Convention: if name.md and name/ both exist as siblings,
+// name.md is the folder's index file and shown as a folder (not a separate file).
+function buildTree(dirPath, basePath = '') {
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+  const items = [];
+
+  const childFolderNames = new Set(
+    entries.filter((e) => e.isDirectory() && !e.name.startsWith('.')).map((e) => e.name)
+  );
+
+  for (const entry of entries) {
+    if (entry.name.startsWith('.') || entry.name === '_meta.json' || entry.name === 'config.json' || entry.name === 'assets') continue;
+
+    const relativePath = basePath ? `${basePath}/${entry.name}` : entry.name;
+
+    if (entry.isDirectory()) {
+      const children = buildTree(path.join(dirPath, entry.name), relativePath);
+
+      // Read metadata from the sibling index .md file
+      const indexFile = path.join(dirPath, entry.name + '.md');
+      const meta = fs.existsSync(indexFile) ? getFileMeta(indexFile) : {};
+
+      items.push({
+        name: entry.name,
+        title: meta.title || formatName(entry.name),
+        path: relativePath,
+        type: 'folder',
+        ordering: meta.ordering,
+        children,
+      });
+    } else if (entry.name.endsWith('.md')) {
+      const nameWithoutExt = entry.name.replace(/\.md$/, '');
+      // If a sibling folder with the same name exists, this .md is the folder index — skip it
+      if (childFolderNames.has(nameWithoutExt)) continue;
+
+      const meta = getFileMeta(path.join(dirPath, entry.name));
+
+      items.push({
+        name: nameWithoutExt,
+        title: meta.title || formatName(nameWithoutExt),
+        path: relativePath.replace(/\.md$/, ''),
+        type: 'file',
+        ordering: meta.ordering,
+      });
+    }
+  }
+
+  // Sort by ordering (type doesn't matter — folders and files intermix).
+  // Items with ordering come first (by value), then items without (alphabetically).
+  items.sort((a, b) => {
+    const aHasOrder = a.ordering !== undefined && a.ordering !== null;
+    const bHasOrder = b.ordering !== undefined && b.ordering !== null;
+
+    if (aHasOrder && bHasOrder) return a.ordering - b.ordering;
+    if (aHasOrder && !bHasOrder) return -1;
+    if (!aHasOrder && bHasOrder) return 1;
+    return a.name.localeCompare(b.name);
+  });
+
+  return items;
+}
+
+// Remove empty folder and clean up (used after delete)
+function cleanupEmptyFolder(folderPath) {
+  if (!fs.existsSync(folderPath)) return;
+  if (!fs.statSync(folderPath).isDirectory()) return;
+
+  const entries = fs.readdirSync(folderPath);
+  if (entries.length === 0) {
+    fs.rmdirSync(folderPath);
+  }
+}
+
+// GET /api/tree — file tree
+router.get('/tree', (req, res) => {
+  try {
+    const tree = buildTree(DOCS_DIR);
+    res.json(tree);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// GET /api/doc/* — read a doc
+router.get('/doc/{*docPath}', (req, res) => {
+  const docPath = getDocPath(req.params);
+  const filePath = path.join(DOCS_DIR, docPath + '.md');
+
+  if (!filePath.startsWith(DOCS_DIR)) {
+    return res.status(403).json({ error: 'Forbidden' });
+  }
+
+  if (!fs.existsSync(filePath)) {
+    return res.status(404).json({ error: 'Not found' });
+  }
+
+  // Check if this doc has a matching folder (i.e. it's a folder index)
+  const folderPath = path.join(DOCS_DIR, docPath);
+  const isFolder = fs.existsSync(folderPath) && fs.statSync(folderPath).isDirectory();
+
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const stat = fs.statSync(filePath);
+  res.json({ content, path: docPath, updatedAt: stat.mtime, isFolder });
+});
+
+// PUT /api/doc/* — create or update a doc
+router.put('/doc/{*docPath}', (req, res) => {
+  const docPath = getDocPath(req.params);
+  const filePath = path.join(DOCS_DIR, docPath + '.md');
+
+  if (!filePath.startsWith(DOCS_DIR)) {
+    return res.status(403).json({ error: 'Forbidden' });
+  }
+
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  fs.writeFileSync(filePath, req.body.content || '', 'utf-8');
+  res.json({ success: true, path: docPath });
+});
+
+// DELETE /api/doc/* — delete a doc
+router.delete('/doc/{*docPath}', (req, res) => {
+  const docPath = getDocPath(req.params);
+  const filePath = path.join(DOCS_DIR, docPath + '.md');
+
+  if (!filePath.startsWith(DOCS_DIR)) {
+    return res.status(403).json({ error: 'Forbidden' });
+  }
+
+  if (!fs.existsSync(filePath)) {
+    return res.status(404).json({ error: 'Not found' });
+  }
+
+  fs.unlinkSync(filePath);
+
+  // Auto-cleanup: if the parent folder is now empty, remove it
+  // so the sibling .md reverts to a plain doc
+  const parentDir = path.dirname(filePath);
+  if (parentDir !== DOCS_DIR) {
+    cleanupEmptyFolder(parentDir);
+  }
+
+  res.json({ success: true });
+});
+
+// POST /api/folder — create a folder (also used to convert a doc into a folder)
+router.post('/folder', (req, res) => {
+  const { path: folderPath } = req.body;
+  const fullPath = path.join(DOCS_DIR, folderPath);
+
+  if (!fullPath.startsWith(DOCS_DIR)) {
+    return res.status(403).json({ error: 'Forbidden' });
+  }
+
+  if (!fs.existsSync(fullPath)) {
+    fs.mkdirSync(fullPath, { recursive: true });
+  }
+
+  // If no sibling index .md exists yet, create one
+  const indexFile = fullPath + '.md';
+  if (!fs.existsSync(indexFile)) {
+    const folderName = path.basename(folderPath);
+    const title = formatName(folderName);
+    fs.writeFileSync(indexFile, `# ${title}\n\n`, 'utf-8');
+  }
+
+  res.json({ success: true, path: folderPath });
+});
+
+// POST /api/move — move/rename a doc or folder
+router.post('/move', (req, res) => {
+  const { from, to } = req.body;
+
+  const fromPath = path.join(DOCS_DIR, from.endsWith('.md') ? from : from + '.md');
+  const toPath = path.join(DOCS_DIR, to.endsWith('.md') ? to : to + '.md');
+
+  if (!fromPath.startsWith(DOCS_DIR) || !toPath.startsWith(DOCS_DIR)) {
+    return res.status(403).json({ error: 'Forbidden' });
+  }
+
+  if (!fs.existsSync(fromPath)) {
+    return res.status(404).json({ error: 'Source not found' });
+  }
+
+  const toDir = path.dirname(toPath);
+  if (!fs.existsSync(toDir)) {
+    fs.mkdirSync(toDir, { recursive: true });
+  }
+
+  fs.renameSync(fromPath, toPath);
+  res.json({ success: true });
+});
+
+// GET /api/folder/* — get folder index content (from sibling .md) + children
+router.get('/folder/{*docPath}', (req, res) => {
+  const folderPath = getDocPath(req.params);
+  const fullPath = path.join(DOCS_DIR, folderPath);
+
+  if (!fullPath.startsWith(DOCS_DIR)) {
+    return res.status(403).json({ error: 'Forbidden' });
+  }
+
+  if (!fs.existsSync(fullPath) || !fs.statSync(fullPath).isDirectory()) {
+    return res.status(404).json({ error: 'Folder not found' });
+  }
+
+  // Read the sibling index file (e.g. guides.md for guides/)
+  const indexFile = fullPath + '.md';
+  let content = '';
+  if (fs.existsSync(indexFile)) {
+    content = fs.readFileSync(indexFile, 'utf-8');
+  }
+
+  // Get direct children (files and folders)
+  const children = buildTree(fullPath, folderPath);
+
+  res.json({ content, path: folderPath, children });
+});
+
+// GET /api/search?q=... — full-text search
+router.get('/search', (req, res) => {
+  const query = req.query.q;
+  if (!query || query.trim().length === 0) {
+    return res.json([]);
+  }
+
+  try {
+    const results = search(DOCS_DIR, query.trim());
+    res.json(results);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+module.exports = router;

package/server/config.js

@@ -0,0 +1,32 @@
+const fs = require('fs');
+const path = require('path');
+
+// Docs path from CLI argument or default to ./docs (relative to CWD)
+const docsArg = process.argv[2] || './docs';
+const docsPath = path.resolve(process.cwd(), docsArg);
+
+// Config lives inside the docs folder
+const configPath = path.join(docsPath, 'config.json');
+
+let config = {
+  docsPath,
+  projectName: 'Doku',
+  port: 4782,
+};
+
+if (fs.existsSync(configPath)) {
+  try {
+    const raw = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    if (raw.projectName) config.projectName = raw.projectName;
+    if (raw.port) config.port = raw.port;
+  } catch {
+    // ignore invalid config
+  }
+}
+
+// PORT env var takes highest priority
+if (process.env.PORT) {
+  config.port = Number(process.env.PORT);
+}
+
+module.exports = config;

package/server/frontmatter.js

@@ -0,0 +1,47 @@
+const FRONTMATTER_REGEX = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+
+function parseFrontmatter(content) {
+  const match = content.match(FRONTMATTER_REGEX);
+  if (!match) {
+    return { frontmatter: {}, body: content };
+  }
+
+  const raw = match[1];
+  const frontmatter = {};
+
+  for (const line of raw.split('\n')) {
+    const idx = line.indexOf(':');
+    if (idx === -1) continue;
+    const key = line.slice(0, idx).trim();
+    let value = line.slice(idx + 1).trim();
+    // Parse numbers
+    if (/^-?\d+(\.\d+)?$/.test(value)) {
+      value = Number(value);
+    }
+    frontmatter[key] = value;
+  }
+
+  const body = content.slice(match[0].length);
+  return { frontmatter, body };
+}
+
+function serializeFrontmatter(frontmatter, body) {
+  const keys = Object.keys(frontmatter);
+  if (keys.length === 0) return body;
+
+  const lines = keys.map((k) => `${k}: ${frontmatter[k]}`);
+  return `---\n${lines.join('\n')}\n---\n${body}`;
+}
+
+function extractTitle(body) {
+  const match = body.match(/^#\s+(.+)$/m);
+  return match ? match[1].trim() : null;
+}
+
+function formatName(slug) {
+  return slug
+    .replace(/-/g, ' ')
+    .replace(/\b\w/g, (c) => c.toUpperCase());
+}
+
+module.exports = { parseFrontmatter, serializeFrontmatter, extractTitle, formatName };

package/server/index.js

@@ -0,0 +1,34 @@
+const express = require('express');
+const cors = require('cors');
+const path = require('path');
+const config = require('./config');
+const api = require('./api');
+
+const app = express();
+const PORT = config.port;
+
+app.use(cors());
+app.use(express.json());
+
+app.use('/api', api);
+
+// Serve static frontend in production
+const distPath = path.join(__dirname, '..', 'dist');
+app.use(express.static(distPath));
+app.get('{*path}', (req, res) => {
+  res.sendFile(path.join(distPath, 'index.html'));
+});
+
+app.listen(PORT, () => {
+  console.log(`Server running at http://localhost:${PORT}`);
+}).on('error', (err) => {
+  console.error('Server error:', err.message);
+});
+
+process.on('uncaughtException', (err) => {
+  console.error('Uncaught exception:', err);
+});
+
+process.on('unhandledRejection', (err) => {
+  console.error('Unhandled rejection:', err);
+});

package/server/search.js

@@ -0,0 +1,62 @@
+const fs = require('fs');
+const path = require('path');
+const { parseFrontmatter, extractTitle, formatName } = require('./frontmatter');
+
+function getAllMdFiles(dir, basePath = '') {
+  const results = [];
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    const relativePath = basePath ? `${basePath}/${entry.name}` : entry.name;
+
+    if (entry.isDirectory() && !entry.name.startsWith('.')) {
+      results.push(...getAllMdFiles(fullPath, relativePath));
+    } else if (entry.name.endsWith('.md')) {
+      results.push({ fullPath, relativePath });
+    }
+  }
+
+  return results;
+}
+
+function search(docsDir, query) {
+  const files = getAllMdFiles(docsDir);
+  const queryLower = query.toLowerCase();
+  const results = [];
+
+  for (const file of files) {
+    const rawContent = fs.readFileSync(file.fullPath, 'utf-8');
+    const { body } = parseFrontmatter(rawContent);
+    const bodyLower = body.toLowerCase();
+    const idx = bodyLower.indexOf(queryLower);
+
+    if (idx === -1) {
+      const nameLower = file.relativePath.toLowerCase();
+      if (!nameLower.includes(queryLower)) continue;
+    }
+
+    // Extract snippet around first match
+    let snippet = '';
+    if (idx !== -1) {
+      const start = Math.max(0, idx - 60);
+      const end = Math.min(body.length, idx + query.length + 60);
+      snippet = (start > 0 ? '...' : '') +
+        body.slice(start, end).replace(/\n/g, ' ') +
+        (end < body.length ? '...' : '');
+    }
+
+    const title = extractTitle(body) ||
+      formatName(file.relativePath.replace(/\.md$/, '').split('/').pop());
+
+    results.push({
+      path: file.relativePath.replace(/\.md$/, ''),
+      title,
+      snippet,
+    });
+  }
+
+  return results.slice(0, 20);
+}
+
+module.exports = search;