mdboard 1.3.0 → 2.1.0

package/src/server/server.js

@@ -2,23 +2,21 @@
 /**
  * mdboard — Project Dashboard Server
  *
- * Zero-dependency Node.js server that reads markdown project management
- * files and serves a visual dashboard + JSON API.
- *
- * Supports multi-repo workspaces via workspace.json.
+ * Config-driven server that reads markdown project management files
+ * and serves a JSON API. No hardcoded entity names.
  *
  * Usage:
  *   mdboard --project /path/to/workspace --port 3333
  */
 
+'use strict';
+
 const http = require('http');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { loadConfig, deepMerge } = require('../core/config');
-const { createModel, scanSource, computeProgress, computeAgentProps, updateMarkdownFile, mergeResults,
-        createTask, createMilestone, createEpic, createSprint, createNote, archiveItem } = require('../core/scanner');
-const { scanAgentConfigs } = require('../core/agent-scanner');
+const { createModel, scanSource, computeProgress, updateEntity, createEntity, deleteEntity, mergeResults } = require('../core/scanner');
 const { setupWatchers, closeWatchers } = require('./watcher');
 const { handleApi } = require('./api');
 const { loadWorkspace, syncAllRemotes, getGitAuthor } = require('../core/workspace');
@@ -58,7 +56,7 @@ let projectPath = path.join(projectDir, 'project');
 const boardDir = path.resolve(__dirname, '..', '..');
 
 // ---------------------------------------------------------------------------
-// Load configuration
+// Load configuration (new config engine)
 // ---------------------------------------------------------------------------
 let config = loadConfig(projectDir, process.env.MDBOARD_CONFIG);
 
@@ -88,17 +86,10 @@ function broadcast(data) {
 // ---------------------------------------------------------------------------
 // Model & scanning — sourceStates tracks per-source state
 // ---------------------------------------------------------------------------
-let model = createModel();
+let model = createModel(config);
 const sourceStates = new Map();
-let aiSuggestions = null;
-
-function refreshAiSuggestions() {
-  try { aiSuggestions = scanAgentConfigs(projectDir); }
-  catch { aiSuggestions = { skills: [], agents: [], mcps: [], commands: [], context: [] }; }
-}
 
 function loadSourceConfig(source) {
-  // Try to load per-source mdboard.json
   if (!source._repoRoot) return config;
   const candidates = [
     path.join(source._resolvedPath, 'mdboard.json'),
@@ -115,11 +106,10 @@ function loadSourceConfig(source) {
 }
 
 function scanAll() {
-  model = createModel();
+  model = createModel(config);
   sourceStates.clear();
 
   if (workspace && sources.length > 0) {
-    // Multi-source mode
     const results = [];
     for (const source of sources) {
       const sourcePath = source._resolvedPath;
@@ -134,21 +124,21 @@ function scanAll() {
         readonly,
       };
 
-      // Load per-source config
       const srcConfig = loadSourceConfig(source);
       const result = scanSource(sourcePath, srcConfig, meta);
 
-      // Add author info if showAuthor is enabled
       if (workspace.settings && workspace.settings.showAuthor) {
         const repoRoot = source._repoRoot;
         if (repoRoot) {
-          for (const task of result.tasks) {
-            task._author = getGitAuthor(repoRoot, task._file);
+          const leafType = getLeafType(srcConfig);
+          if (leafType && result.entities[leafType]) {
+            for (const item of result.entities[leafType]) {
+              item._author = getGitAuthor(repoRoot, item._file);
+            }
           }
         }
       }
 
-      // Store per-source state
       sourceStates.set(source.name, {
         model: result,
         config: srcConfig,
@@ -161,27 +151,59 @@ function scanAll() {
     }
     mergeResults(model, results);
   } else {
-    // Legacy single-source mode
     const result = scanSource(projectPath, config, {});
     mergeResults(model, [result]);
   }
 
-  computeProgress(model, config.completedStatus);
-  computeAgentProps(model);
-  refreshAiSuggestions();
+  computeProgress(model, config);
+}
+
+function getLeafType(cfg) {
+  const { flattenHierarchy } = require('../core/config');
+  const flat = flattenHierarchy(cfg);
+  const h = flat.filter(e => !e.standalone);
+  return h.length > 0 ? h[h.length - 1].type : null;
 }
 
 // ---------------------------------------------------------------------------
-// File update helper — resolves correct projectPath per source
+// File update helper
 // ---------------------------------------------------------------------------
 function updateFile(sourceName, relFile, updates) {
+  let sourcePath = projectPath;
+  if (sourceName && sources.length > 0) {
+    const source = sources.find(s => s.name === sourceName);
+    if (source && source._resolvedPath) sourcePath = source._resolvedPath;
+  }
+  return updateEntity(sourcePath, relFile, updates);
+}
+
+// ---------------------------------------------------------------------------
+// CRUD helpers — dynamic, uses entityType not collection name
+// ---------------------------------------------------------------------------
+function createItemFn(sourceName, entityType, data) {
+  let sourcePath = projectPath;
+  let cfg = config;
+
   if (sourceName && sources.length > 0) {
     const source = sources.find(s => s.name === sourceName);
     if (source && source._resolvedPath) {
-      return updateMarkdownFile(source._resolvedPath, relFile, updates);
+      sourcePath = source._resolvedPath;
+      const state = sourceStates.get(sourceName);
+      if (state) cfg = state.config;
     }
   }
-  return updateMarkdownFile(projectPath, relFile, updates);
+
+  const existingItems = model.entities[entityType] || [];
+  return createEntity(sourcePath, cfg, entityType, data, existingItems);
+}
+
+function deleteItemFn(sourceName, item) {
+  let sourcePath = projectPath;
+  if (sourceName && sources.length > 0) {
+    const source = sources.find(s => s.name === sourceName);
+    if (source && source._resolvedPath) sourcePath = source._resolvedPath;
+  }
+  return deleteEntity(sourcePath, item);
 }
 
 // ---------------------------------------------------------------------------
@@ -189,7 +211,6 @@ function updateFile(sourceName, relFile, updates) {
 // ---------------------------------------------------------------------------
 async function doSyncRemotes() {
   if (!workspace || sources.length === 0) return;
-
   const remoteSources = sources.filter(s => s.type === 'remote');
   if (remoteSources.length === 0) return;
 
@@ -235,6 +256,15 @@ function findCustomCss() {
   return null;
 }
 
+// Cache index.html at startup
+let _indexHtmlCache = null;
+function getIndexHtml() {
+  if (!_indexHtmlCache) {
+    try { _indexHtmlCache = fs.readFileSync(path.join(boardDir, 'index.html')); } catch { /* */ }
+  }
+  return _indexHtmlCache;
+}
+
 function serveStatic(req, res) {
   const url = new URL(req.url, `http://localhost:${port}`);
 
@@ -253,94 +283,19 @@ function serveStatic(req, res) {
     return;
   }
 
-  if (url.pathname === '/logo') {
-    if (config.logo && !config.logo.startsWith('http')) {
-      const logoPath = path.resolve(projectDir, config.logo);
-      if (logoPath.startsWith(projectDir) && fs.existsSync(logoPath)) {
-        try {
-          const logoContent = fs.readFileSync(logoPath);
-          const logoExt = path.extname(logoPath);
-          const logoMime = MIME_TYPES[logoExt] || 'application/octet-stream';
-          res.writeHead(200, { 'Content-Type': logoMime });
-          res.end(logoContent);
-          return;
-        } catch { /* fall through */ }
-      }
-    }
-    res.writeHead(404);
-    res.end('Not found');
-    return;
-  }
-
-  let filePath = path.join(boardDir, 'index.html');
-  if (!filePath.startsWith(boardDir)) {
-    res.writeHead(403);
-    res.end('Forbidden');
-    return;
-  }
-
-  const ext = path.extname(filePath);
-  const contentType = MIME_TYPES[ext] || 'text/plain';
-
-  try {
-    const content = fs.readFileSync(filePath);
-    res.writeHead(200, { 'Content-Type': contentType });
+  const content = getIndexHtml();
+  if (content) {
+    res.writeHead(200, { 'Content-Type': 'text/html' });
     res.end(content);
-  } catch {
+  } else {
     res.writeHead(404);
     res.end('Not found');
   }
 }
 
 // ---------------------------------------------------------------------------
-// HTTP server
-// ---------------------------------------------------------------------------
-// ---------------------------------------------------------------------------
-// CRUD helpers — resolve source path and delegate to scanner
+// API context
 // ---------------------------------------------------------------------------
-function createItemFn(sourceName, collection, data) {
-  let sourcePath = projectPath;
-  let cfg = config;
-
-  if (sourceName && sources.length > 0) {
-    const source = sources.find(s => s.name === sourceName);
-    if (source && source._resolvedPath) {
-      sourcePath = source._resolvedPath;
-      const state = sourceStates.get(sourceName);
-      if (state) cfg = state.config;
-    }
-  }
-
-  // Use ALL items across sources to compute next ID — prevents cross-source collisions
-  switch (collection) {
-    case 'tasks':
-      return createTask(sourcePath, cfg, data, model.tasks);
-    case 'milestones':
-      return createMilestone(sourcePath, cfg, data, model.milestones);
-    case 'epics':
-      return createEpic(sourcePath, cfg, data, model.epics);
-    case 'sprints':
-      return createSprint(sourcePath, cfg, data, model.sprints);
-    case 'notes':
-      return createNote(sourcePath, data, model.notes);
-    default:
-      throw new Error('Unknown collection: ' + collection);
-  }
-}
-
-function archiveItemFn(sourceName, item) {
-  let sourcePath = projectPath;
-
-  if (sourceName && sources.length > 0) {
-    const source = sources.find(s => s.name === sourceName);
-    if (source && source._resolvedPath) {
-      sourcePath = source._resolvedPath;
-    }
-  }
-
-  return archiveItem(sourcePath, item);
-}
-
 const apiCtx = {
   get model() { return model; },
   get config() { return config; },
@@ -352,18 +307,33 @@ const apiCtx = {
   broadcast,
   updateFile,
   rescanAll: () => scanAll(),
+  reloadConfig: () => reloadConfig(),
   syncRemotes: doSyncRemotes,
   createItem: createItemFn,
-  archiveItem: archiveItemFn,
-  getAiSuggestions: () => aiSuggestions || { skills: [], agents: [], mcps: [], commands: [], context: [] },
+  deleteItem: deleteItemFn,
   get hasProject() {
     return fs.existsSync(path.join(projectDir, 'project')) ||
       (workspace && sources.length > 0);
   },
   loadProject: loadProject,
   getProjectHistory: () => getHistory(projectDir),
+  get workspacePath() {
+    return workspace ? workspace._path : (workspacePath || path.join(projectDir, 'workspace.json'));
+  },
+  onWorkspaceChange() {
+    workspace = loadWorkspace(projectDir, workspacePath);
+    sources = workspace ? workspace.sources : [];
+    closeWatchers(activeWatchers);
+    scanAll();
+    activeWatchers = setupWatchers(buildWatcherOpts());
+    doSyncRemotes().catch(() => {});
+    broadcast({ type: 'update', timestamp: new Date().toISOString() });
+  },
 };
 
+// ---------------------------------------------------------------------------
+// HTTP server
+// ---------------------------------------------------------------------------
 const server = http.createServer(async (req, res) => {
   try {
     if (req.url.startsWith('/api/')) {
@@ -428,44 +398,31 @@ if (isValidProject(projectDir)) {
 
 /**
  * Load a different project directory dynamically.
- *
- * @param {string} newProjectDir - Absolute path to the new project
  */
 function loadProject(newProjectDir) {
-  // 1. Close existing watchers
   closeWatchers(activeWatchers);
-
-  // 2. Stop sync interval
   if (syncInterval) clearInterval(syncInterval);
   syncInterval = null;
 
-  // 3. Update paths
   projectDir = path.resolve(newProjectDir);
   projectPath = path.join(projectDir, 'project');
   workspacePath = null;
 
-  // 4. Reload config
-  config = loadConfig(projectDir);
+  // Clear startup preset so each project resolves its own
+  delete process.env.MDBOARD_PRESET;
 
-  // 5. Reload workspace
+  config = loadConfig(projectDir);
   workspace = loadWorkspace(projectDir, null);
   sources = workspace ? workspace.sources : [];
 
-  // 6. Rescan
   scanAll();
-
-  // 7. Setup new watchers
   activeWatchers = setupWatchers(buildWatcherOpts());
 
-  // 8. Restart remote sync
   doSyncRemotes().catch(() => {});
   startSyncInterval();
 
-  // 9. Register in history
   const projName = (model.project && model.project.name) || path.basename(projectDir);
   registerProject(projectDir, projName);
-
-  // 10. Broadcast to SSE clients
   broadcast({ type: 'project-changed', projectDir });
 }
 
@@ -478,11 +435,26 @@ server.listen(port, () => {
     ? `\n     Sources: ${sources.map(s => s.label || s.name).join(', ')}`
     : '';
   const watchCount = activeWatchers.length;
+
+  // Resolve leaf type for tips
+  const { flattenHierarchy } = require('../core/config');
+  const flat = flattenHierarchy(config);
+  const hierarchy = flat.filter(e => !e.standalone);
+  const leafType = hierarchy.length > 0 ? hierarchy[hierarchy.length - 1].type : null;
+
   console.log(`
   mdboard — Project Dashboard
      Project: ${projectDir}
-     Server:  http://localhost:${port}${config._path ? '\n     Config:  ' + config._path : ''}${sourceInfo}
+     Server:  http://localhost:${port}${config._entitiesPath ? '\n     Config:  ' + config._entitiesPath : ''}${sourceInfo}
 ${watchCount > 0 ? '\n     Watching ' + watchCount + ' director' + (watchCount === 1 ? 'y' : 'ies') + ' for changes...' : ''}
+  Open in browser:
+     http://localhost:${port}
+
+  Quick start:
+     mdboard config             Setup preferences & AI skill
+     mdboard preset list        Switch methodology (scrum, kanban, ...)
+     mdboard skill              Add AI skill to your IDE${leafType ? '\n     mdboard create ' + leafType + ' "title"   Create a new ' + leafType : ''}
+     mdboard --help             Show all commands
 `);
 });
 
@@ -509,3 +481,6 @@ process.on('SIGTERM', () => {
   closeWatchers(activeWatchers);
   server.close(() => process.exit(0));
 });
+
+// Export for programmatic use in tests
+module.exports = { server, scanAll, apiCtx };

package/build.js

@@ -1,44 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-
-const CLIENT_DIR = path.join(__dirname, 'src', 'client');
-const OUT_FILE = path.join(__dirname, 'index.html');
-
-const JS_FILES = [
-  'themes.js',
-  'core.js',
-  'workspace.js',
-  'editor.js',
-  'board.js',
-  'table.js',
-  'milestones.js',
-  'metrics.js',
-  'overview.js',
-  'notes.js',
-  'panel.js',
-  'history.js',
-  'app.js',
-];
-
-// Read template
-const template = fs.readFileSync(path.join(CLIENT_DIR, 'template.html'), 'utf8');
-
-// Read CSS
-const css = fs.readFileSync(path.join(CLIENT_DIR, 'styles.css'), 'utf8');
-
-// Read and concatenate JS files
-const js = JS_FILES
-  .map(f => fs.readFileSync(path.join(CLIENT_DIR, f), 'utf8'))
-  .join('\n\n');
-
-// Replace placeholders
-let output = template.replace('<!-- STYLES -->', css);
-output = output.replace('<!-- SCRIPTS -->', js);
-
-fs.writeFileSync(OUT_FILE, output, 'utf8');
-
-const lines = output.split('\n').length;
-console.log(`Built index.html (${lines} lines, ${Buffer.byteLength(output)} bytes)`);

package/defaults.json

@@ -1,43 +0,0 @@
-{
-  "entities": {
-    "milestone": { "singular": "Milestone", "plural": "Milestones", "dir": "milestones" },
-    "epic":      { "singular": "Epic", "plural": "Epics", "dir": "epics" },
-    "task":      { "singular": "Task", "plural": "Tasks", "dir": "backlog", "prefix": "TASK", "legacyPrefixes": ["FEAT"] },
-    "sprint":    { "singular": "Sprint", "plural": "Sprints", "dir": "sprints" }
-  },
-  "statuses": {
-    "task": [
-      { "key": "backlog",     "label": "Backlog",     "color": "#5A5A63", "icon": "dashed-circle" },
-      { "key": "todo",        "label": "Todo",        "color": "#8B8B93", "icon": "circle" },
-      { "key": "in-progress", "label": "In Progress", "color": "#D4A72C", "icon": "half-circle" },
-      { "key": "in-review",   "label": "In Review",   "color": "#8B5CF6", "icon": "three-quarter-circle" },
-      { "key": "done",        "label": "Done",        "color": "#2EA043", "icon": "check-circle" },
-      { "key": "blocked",     "label": "Blocked",     "color": "#DA3633", "icon": "x-circle" },
-      { "key": "cancelled",   "label": "Cancelled",   "color": "#5A5A63", "icon": "slash-circle" }
-    ],
-    "milestone": [
-      { "key": "planned",   "label": "Planned",   "color": "#8B8B93" },
-      { "key": "active",    "label": "Active",    "color": "#5B6EF5" },
-      { "key": "completed", "label": "Completed", "color": "#2EA043" }
-    ],
-    "epic": [
-      { "key": "active",    "label": "Active",    "color": "#5B6EF5" },
-      { "key": "completed", "label": "Completed", "color": "#2EA043" },
-      { "key": "blocked",   "label": "Blocked",   "color": "#DA3633" }
-    ],
-    "sprint": [
-      { "key": "planned",   "label": "Planned",   "color": "#8B8B93" },
-      { "key": "active",    "label": "Active",    "color": "#5B6EF5" },
-      { "key": "completed", "label": "Completed", "color": "#2EA043" },
-      { "key": "cancelled", "label": "Cancelled", "color": "#DA3633" }
-    ]
-  },
-  "boardColumns": ["backlog", "todo", "in-progress", "in-review", "done"],
-  "priorities": [
-    { "key": "urgent", "label": "Urgent", "color": "#F97316", "bars": 4 },
-    { "key": "high",   "label": "High",   "color": "#F97316", "bars": 3 },
-    { "key": "medium", "label": "Medium", "color": "#D4A72C", "bars": 2 },
-    { "key": "low",    "label": "Low",    "color": "#5B6EF5", "bars": 1 }
-  ],
-  "completedStatus": "done"
-}

package/src/cli/sync.js

@@ -1,194 +0,0 @@
-/**
- * mdboard — Consistency checker
- *
- * Detects dangling references and inconsistencies in the project model.
- * With --fix, auto-corrects fixable issues.
- *
- * Usage:
- *   mdboard sync          Report issues
- *   mdboard sync --fix    Auto-fix fixable issues
- */
-
-const fs = require('fs');
-const path = require('path');
-const { buildModel } = require('./cli');
-const { updateMarkdownFile } = require('../core/scanner');
-
-/**
- * Run consistency checks on the project model.
- *
- * @param {string} projectDir - Workspace root directory
- * @param {{ fix?: boolean }} opts - Options
- */
-function runSync(projectDir, opts) {
-  const fix = opts && opts.fix;
-  const { model, config, projectPath } = buildModel(projectDir);
-
-  const issues = [];
-
-  const taskIds = new Set(model.tasks.map(t => t.id));
-  const sprintIds = new Set(model.sprints.map(s => s.id));
-  const epicIds = new Set(model.epics.map(e => e.id));
-  const milestoneIds = new Set(model.milestones.map(m => m.id));
-
-  // 1. sprint.features[] references tasks that don't exist
-  for (const sprint of model.sprints) {
-    if (!sprint.features || !Array.isArray(sprint.features)) continue;
-    const missing = sprint.features.filter(f => !taskIds.has(f));
-    if (missing.length > 0) {
-      issues.push({
-        type: 'error',
-        fixable: true,
-        message: `Sprint ${sprint.id}: features[] references missing tasks: ${missing.join(', ')}`,
-        fix: () => {
-          const newFeatures = sprint.features.filter(f => taskIds.has(f));
-          updateMarkdownFile(projectPath, sprint._file, { features: newFeatures });
-        },
-      });
-    }
-  }
-
-  // 2. task.sprint references sprint that doesn't exist
-  for (const task of model.tasks) {
-    if (!task.sprint) continue;
-    if (!sprintIds.has(task.sprint)) {
-      issues.push({
-        type: 'error',
-        fixable: true,
-        message: `Task ${task.id}: sprint "${task.sprint}" does not exist`,
-        fix: () => {
-          updateMarkdownFile(projectPath, task._file, { sprint: null });
-        },
-      });
-    }
-  }
-
-  // 3. epic.dependencies[] references epics that don't exist
-  for (const epic of model.epics) {
-    if (!epic.dependencies || !Array.isArray(epic.dependencies)) continue;
-    const missing = epic.dependencies.filter(d => !epicIds.has(d));
-    if (missing.length > 0) {
-      issues.push({
-        type: 'error',
-        fixable: true,
-        message: `Epic ${epic.id}: dependencies[] references missing epics: ${missing.join(', ')}`,
-        fix: () => {
-          const newDeps = epic.dependencies.filter(d => epicIds.has(d));
-          updateMarkdownFile(projectPath, epic._file, { dependencies: newDeps });
-        },
-      });
-    }
-  }
-
-  // 4. milestone.tracks[] references milestones that don't exist
-  for (const ms of model.milestones) {
-    if (!ms.tracks || !Array.isArray(ms.tracks)) continue;
-    const missing = ms.tracks.filter(t => {
-      // tracks can reference source:MS-ID format
-      if (String(t).includes(':')) {
-        const parts = String(t).split(':');
-        const refId = parts[1];
-        return !model.milestones.some(m => m.id === t || m._originalId === refId || m.id === refId);
-      }
-      return !milestoneIds.has(t);
-    });
-    if (missing.length > 0) {
-      issues.push({
-        type: 'warning',
-        fixable: false,
-        message: `Milestone ${ms.id}: tracks[] references missing milestones: ${missing.join(', ')}`,
-      });
-    }
-  }
-
-  // 5. Duplicate IDs in the same collection
-  const collections = [
-    { name: 'tasks', items: model.tasks },
-    { name: 'milestones', items: model.milestones },
-    { name: 'epics', items: model.epics },
-    { name: 'sprints', items: model.sprints },
-  ];
-
-  for (const col of collections) {
-    const seen = new Map();
-    for (const item of col.items) {
-      if (!item.id) continue;
-      if (seen.has(item.id)) {
-        issues.push({
-          type: 'error',
-          fixable: false,
-          message: `Duplicate ${col.name.slice(0, -1)} ID "${item.id}": ${seen.get(item.id)} and ${item._file}`,
-        });
-      } else {
-        seen.set(item.id, item._file);
-      }
-    }
-  }
-
-  // 6. Tasks under epic directory without epic README.md
-  const msDir = config.entities.milestone.dir;
-  const epicDir = config.entities.epic.dir;
-  const taskDir = config.entities.task.dir;
-
-  for (const task of model.tasks) {
-    if (!task._epic || !task._milestone) continue;
-    const epicReadmePath = path.join(projectPath, msDir, task._milestone, epicDir, task._epic, 'README.md');
-    if (!fs.existsSync(epicReadmePath)) {
-      issues.push({
-        type: 'warning',
-        fixable: false,
-        message: `Task ${task.id}: parent epic directory "${task._epic}" has no README.md`,
-      });
-    }
-  }
-
-  // 7. Sprints under milestone without milestone README.md
-  for (const sprint of model.sprints) {
-    if (!sprint._milestone) continue;
-    const msReadmePath = path.join(projectPath, msDir, sprint._milestone, 'README.md');
-    if (!fs.existsSync(msReadmePath)) {
-      issues.push({
-        type: 'warning',
-        fixable: false,
-        message: `Sprint ${sprint.id}: parent milestone directory "${sprint._milestone}" has no README.md`,
-      });
-    }
-  }
-
-  // Report
-  if (issues.length === 0) {
-    console.log('\n  mdboard sync — No issues found.\n');
-    return;
-  }
-
-  const errors = issues.filter(i => i.type === 'error');
-  const warnings = issues.filter(i => i.type === 'warning');
-  const fixable = issues.filter(i => i.fixable);
-
-  console.log('');
-  for (const issue of issues) {
-    const prefix = issue.type === 'error' ? '  ERROR' : '  WARN ';
-    const suffix = issue.fixable ? ' [fixable]' : '';
-    console.log(`${prefix}: ${issue.message}${suffix}`);
-  }
-  console.log('');
-
-  if (fix && fixable.length > 0) {
-    for (const issue of fixable) {
-      issue.fix();
-    }
-    console.log(`  mdboard sync --fix — Fixed ${fixable.length} issue${fixable.length > 1 ? 's' : ''}.`);
-    if (warnings.length > 0) {
-      console.log(`  ${warnings.length} warning${warnings.length > 1 ? 's' : ''} remain (not auto-fixable).`);
-    }
-    console.log('');
-  } else {
-    console.log(`  mdboard sync — ${issues.length} issue${issues.length > 1 ? 's' : ''} (${errors.length} error${errors.length > 1 ? 's' : ''}, ${warnings.length} warning${warnings.length > 1 ? 's' : ''}).${fixable.length > 0 ? ` ${fixable.length} fixable.` : ''}`);
-    if (fixable.length > 0) {
-      console.log('  Run `mdboard sync --fix` to auto-correct.');
-    }
-    console.log('');
-  }
-}
-
-module.exports = { runSync };