mdboard 1.2.0 → 2.0.0

package/src/cli/preset.js

@@ -0,0 +1,849 @@
+/**
+ * mdboard preset — Create and manage methodology presets
+ *
+ * Presets define the full config (6 JSON files) for a methodology.
+ * Built-in templates: scrum, kanban. Given entities + structure,
+ * the other 4 files (cli, api, ui, docs) are auto-derived.
+ *
+ * Usage:
+ *   mdboard preset list                    List available presets
+ *   mdboard preset create <name>           Create from built-in template
+ *   mdboard preset create <name> --from X  Copy existing preset
+ *   mdboard preset show <name>             Show preset summary
+ */
+
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+var configEngine = require('../core/config');
+
+// ── Built-in templates ──────────────────────────────────────────────
+
+var TEMPLATES = {
+  scrum: buildScrum,
+  kanban: buildKanban,
+};
+
+function buildScrum() {
+  var entities = {
+    methodology: 'scrum',
+    entities: {
+      sprint: {
+        singular: 'Sprint',
+        plural: 'Sprints',
+        prefix: 'SPR',
+        file: 'README.md',
+        fields: {
+          status: {
+            type: 'enum',
+            values: [
+              { key: 'planned',   label: 'Planned',   color: '#8B8B93', icon: 'dashed-circle' },
+              { key: 'active',    label: 'Active',     color: '#5B6EF5', icon: 'half-circle' },
+              { key: 'completed', label: 'Completed',  color: '#2EA043', icon: 'check-circle' }
+            ],
+            default: 'planned'
+          },
+          goal:       { type: 'string', label: 'Goal' },
+          start_date: { type: 'date',   label: 'Start' },
+          end_date:   { type: 'date',   label: 'End' }
+        }
+      },
+      story: {
+        singular: 'Story',
+        plural: 'Stories',
+        prefix: 'US',
+        file: 'README.md',
+        fields: {
+          status: {
+            type: 'enum',
+            values: [
+              { key: 'backlog',     label: 'Backlog',     color: '#8B8B93', icon: 'circle' },
+              { key: 'ready',       label: 'Ready',       color: '#06B6D4', icon: 'dashed-circle' },
+              { key: 'in-progress', label: 'In Progress', color: '#D4A72C', icon: 'half-circle' },
+              { key: 'review',      label: 'Review',      color: '#8B5CF6', icon: 'three-quarter-circle' },
+              { key: 'done',        label: 'Done',        color: '#2EA043', icon: 'check-circle' }
+            ],
+            default: 'backlog'
+          },
+          points:   { type: 'number', label: 'Points' },
+          assigned: { type: 'list',   label: 'Assigned' }
+        }
+      },
+      task: {
+        singular: 'Task',
+        plural: 'Tasks',
+        prefix: 'TASK',
+        file: 'PREFIX-NNN.md',
+        fields: {
+          status: {
+            type: 'enum',
+            values: [
+              { key: 'todo',        label: 'Todo',        color: '#8B8B93', icon: 'circle' },
+              { key: 'in-progress', label: 'In Progress', color: '#D4A72C', icon: 'half-circle' },
+              { key: 'done',        label: 'Done',        color: '#2EA043', icon: 'check-circle' }
+            ],
+            default: 'todo'
+          },
+          assigned: { type: 'list',   label: 'Assigned' },
+          points:   { type: 'number', label: 'Points' }
+        }
+      },
+      epic: {
+        singular: 'Epic',
+        plural: 'Epics',
+        prefix: 'EPIC',
+        file: 'README.md',
+        fields: {
+          status: {
+            type: 'enum',
+            values: [
+              { key: 'open',   label: 'Open',   color: '#5B6EF5', icon: 'circle' },
+              { key: 'closed', label: 'Closed',  color: '#2EA043', icon: 'check-circle' }
+            ],
+            default: 'open'
+          }
+        }
+      },
+      bug: {
+        singular: 'Bug',
+        plural: 'Bugs',
+        prefix: 'BUG',
+        file: 'PREFIX-NNN.md',
+        fields: {
+          status: {
+            type: 'enum',
+            values: [
+              { key: 'open',        label: 'Open',        color: '#DA3633', icon: 'circle' },
+              { key: 'in-progress', label: 'In Progress', color: '#D4A72C', icon: 'half-circle' },
+              { key: 'fixed',       label: 'Fixed',        color: '#2EA043', icon: 'check-circle' }
+            ],
+            default: 'open'
+          },
+          severity: {
+            type: 'enum',
+            values: [
+              { key: 'critical', label: 'Critical', color: '#DA3633' },
+              { key: 'major',    label: 'Major',    color: '#F97316' },
+              { key: 'minor',    label: 'Minor',    color: '#D4A72C' }
+            ],
+            default: 'major'
+          },
+          assigned: { type: 'list', label: 'Assigned' }
+        }
+      },
+      note: {
+        singular: 'Note',
+        plural: 'Notes',
+        prefix: 'NOTE',
+        file: 'PREFIX-NNN.md',
+        fields: {
+          updated: { type: 'date', label: 'Updated' }
+        }
+      }
+    },
+    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 }
+    ],
+    completedStatuses: ['done', 'completed', 'fixed', 'closed']
+  };
+
+  var structure = {
+    root: 'project',
+    hierarchy: {
+      sprint: {
+        dir: 'sprints',
+        children: {
+          story: {
+            dir: 'stories',
+            children: {
+              task: { dir: 'tasks' }
+            }
+          }
+        }
+      }
+    },
+    standalone: {
+      epic: { dir: 'epics' },
+      bug:  { dir: 'bugs' },
+      note: { dir: 'notes' }
+    },
+    archive: { dir: 'archive' }
+  };
+
+  return { entities: entities, structure: structure };
+}
+
+function buildKanban() {
+  var entities = {
+    methodology: 'kanban',
+    entities: {
+      task: {
+        singular: 'Task',
+        plural: 'Tasks',
+        prefix: 'TASK',
+        file: 'PREFIX-NNN.md',
+        fields: {
+          status: {
+            type: 'enum',
+            values: [
+              { key: 'backlog',     label: 'Backlog',     color: '#8B8B93', icon: 'circle' },
+              { key: 'todo',        label: 'Todo',        color: '#06B6D4', icon: 'dashed-circle' },
+              { key: 'in-progress', label: 'In Progress', color: '#D4A72C', icon: 'half-circle' },
+              { key: 'review',      label: 'Review',      color: '#8B5CF6', icon: 'three-quarter-circle' },
+              { key: 'done',        label: 'Done',        color: '#2EA043', icon: 'check-circle' }
+            ],
+            default: 'backlog'
+          },
+          priority: {
+            type: 'enum',
+            values: [
+              { key: 'urgent', label: 'Urgent', color: '#DA3633' },
+              { key: 'high',   label: 'High',   color: '#F97316' },
+              { key: 'medium', label: 'Medium', color: '#D4A72C' },
+              { key: 'low',    label: 'Low',    color: '#5B6EF5' }
+            ],
+            default: 'medium'
+          },
+          assigned: { type: 'list',   label: 'Assigned' },
+          points:   { type: 'number', label: 'Points' },
+          tags:     { type: 'list',   label: 'Tags' }
+        }
+      },
+      note: {
+        singular: 'Note',
+        plural: 'Notes',
+        prefix: 'NOTE',
+        file: 'PREFIX-NNN.md',
+        fields: {
+          updated: { type: 'date', label: 'Updated' }
+        }
+      }
+    },
+    priorities: [
+      { key: 'urgent', label: 'Urgent', color: '#DA3633', 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 }
+    ],
+    completedStatuses: ['done']
+  };
+
+  // Kanban: flat, no hierarchy
+  var structure = {
+    root: 'project',
+    hierarchy: {},
+    standalone: {
+      task: { dir: 'tasks' },
+      note: { dir: 'notes' }
+    },
+    archive: { dir: 'archive' }
+  };
+
+  return { entities: entities, structure: structure };
+}
+
+// ── Auto-derivation ─────────────────────────────────────────────────
+
+function deriveCliConfig(entities, structure) {
+  var allTypes = Object.keys(entities.entities);
+
+  return {
+    commands: {
+      create: { entities: allTypes, args: { positional: 'title', flags: 'auto' } },
+      update: { entities: allTypes, args: { positional: 'id', flags: 'auto' } },
+      delete: { entities: allTypes, action: 'archive' },
+      status: {
+        output: 'status.md',
+        sections: deriveStatusSections(entities, structure)
+      },
+      sync: {
+        checks: ['dangling-refs', 'duplicate-ids', 'missing-parents', 'orphaned-tasks'],
+        fix: true
+      },
+      init: { presets: ['shape-up', 'scrum', 'kanban'], default: entities.methodology },
+      theme: { scope: ['global', 'project'] },
+      cache: { subcommands: ['list', 'clean'] }
+    }
+  };
+}
+
+function deriveStatusSections(entities, structure) {
+  var sections = [];
+  var leafType = findLeafType(structure);
+  var rootType = findRootType(structure);
+
+  // Summary metrics
+  var metrics = [];
+  if (rootType) {
+    metrics.push({ label: capitalize(entities.entities[rootType].plural), compute: 'count', entity: rootType });
+  }
+  if (leafType) {
+    metrics.push({ label: capitalize(entities.entities[leafType].plural), compute: 'count', entity: leafType, detail: 'done-ratio' });
+  }
+  sections.push({ type: 'summary', metrics: metrics });
+
+  // Entity list from root
+  if (rootType) {
+    var midType = findMidType(structure);
+    var listSection = { type: 'entity-list', entity: rootType, fields: ['title', 'status', 'progress'] };
+    if (midType) {
+      listSection.nest = { entity: midType, fields: ['title', 'status'] };
+    }
+    sections.push(listSection);
+  }
+
+  // Table of leaf type
+  if (leafType) {
+    sections.push({ type: 'entity-table', entity: leafType, groupBy: 'status', fields: ['id', 'title', 'status', 'points'] });
+  }
+
+  return sections;
+}
+
+function deriveApiConfig(entities, structure) {
+  var allTypes = Object.keys(entities.entities);
+  var activeStatuses = ['active', 'in-progress', 'building'];
+
+  // Find types that have "active-like" statuses
+  var activeEntities = [];
+  for (var i = 0; i < allTypes.length; i++) {
+    var e = entities.entities[allTypes[i]];
+    if (e.fields && e.fields.status) {
+      var keys = e.fields.status.values.map(function (v) { return v.key; });
+      for (var j = 0; j < activeStatuses.length; j++) {
+        if (keys.indexOf(activeStatuses[j]) !== -1) {
+          activeEntities.push(allTypes[i]);
+          break;
+        }
+      }
+    }
+  }
+
+  return {
+    endpoints: {
+      crud: {
+        entities: allTypes,
+        operations: ['list', 'get', 'create', 'update', 'delete'],
+        pattern: '/api/:entity',
+        sourceScoped: true,
+        sourcePattern: '/api/sources/:source/:entity'
+      },
+      queries: {
+        active: {
+          pattern: '/api/:entity/active',
+          filter: { status: activeStatuses },
+          entities: activeEntities
+        },
+        metrics: {
+          pattern: '/api/metrics',
+          computes: ['status-breakdown', 'priority-distribution', 'progress-by-parent']
+        },
+        health: {
+          pattern: '/api/health',
+          computes: ['total', 'completed', 'in-progress', 'velocity']
+        }
+      },
+      system: {
+        config:  { method: 'GET',  path: '/api/config' },
+        project: { method: 'GET',  path: '/api/project' },
+        sources: { method: 'GET',  path: '/api/sources' },
+        sync:    { method: 'POST', path: '/api/sources/sync' },
+        history: { method: 'GET',  path: '/api/history' },
+        switch:  { method: 'POST', path: '/api/history/switch' },
+        theme:   { method: 'POST', path: '/api/theme' },
+        events:  { method: 'GET',  path: '/api/events', type: 'sse' }
+      }
+    },
+    filtering: { strategy: 'query-params', autoFilters: true }
+  };
+}
+
+function deriveUiConfig(entities, structure) {
+  var tabs = [];
+  var hierarchyTypes = flattenHierarchyTypes(structure);
+  var standaloneTypes = Object.keys(structure.standalone || {});
+  var leafType = hierarchyTypes.length > 0 ? hierarchyTypes[hierarchyTypes.length - 1] : null;
+  var rootType = hierarchyTypes.length > 0 ? hierarchyTypes[0] : null;
+
+  // Leaf hierarchy → board + table + list
+  if (leafType) {
+    var e = entities.entities[leafType];
+    tabs.push({
+      id: e.plural.toLowerCase(),
+      label: e.plural,
+      description: e.plural + ' — leaf work items',
+      icon: 'check-square',
+      entity: leafType,
+      layouts: ['board', 'table', 'list'],
+      defaultLayout: 'board',
+      board: { groupBy: 'status', cardFields: ['id', 'title', 'status'], dragAction: 'update-status' },
+      table: { columns: buildTableColumns(leafType, entities, hierarchyTypes), sortable: true },
+      filters: 'auto'
+    });
+  }
+
+  // Mid hierarchy → cards + list with expandChildren
+  for (var m = hierarchyTypes.length - 2; m >= 1; m--) {
+    var midType = hierarchyTypes[m];
+    var childType = hierarchyTypes[m + 1];
+    var me = entities.entities[midType];
+    var ce = entities.entities[childType];
+    tabs.push({
+      id: me.plural.toLowerCase(),
+      label: me.plural,
+      description: me.plural,
+      icon: 'layers',
+      entity: midType,
+      layouts: ['cards', 'list'],
+      defaultLayout: 'cards',
+      cards: {
+        fields: ['title', 'status'],
+        showProgress: true,
+        expandChildren: { entity: childType, fields: ['title', 'status'] }
+      },
+      list: { fields: ['title', 'status', 'progress'], expandable: true },
+      filters: 'auto'
+    });
+  }
+
+  // Root hierarchy → list with expandChildren
+  if (rootType && hierarchyTypes.length > 1) {
+    var re = entities.entities[rootType];
+    var firstChild = hierarchyTypes[1];
+    tabs.push({
+      id: re.plural.toLowerCase(),
+      label: re.plural,
+      description: re.plural,
+      icon: 'refresh-cw',
+      entity: rootType,
+      layouts: ['list'],
+      defaultLayout: 'list',
+      list: {
+        fields: buildListFields(rootType, entities),
+        expandChildren: { entity: firstChild, fields: ['title', 'status'] }
+      },
+      filters: ['status']
+    });
+  }
+
+  // Standalone with status → board + cards (kanban edge case: promoted to primary)
+  for (var s = 0; s < standaloneTypes.length; s++) {
+    var st = standaloneTypes[s];
+    var se = entities.entities[st];
+    if (!se) continue;
+
+    var hasStatus = se.fields && se.fields.status;
+    var isNoteType = st === 'note' || (!hasStatus && !se.fields.priority);
+
+    if (isNoteType) {
+      // Note-like → editor
+      tabs.push({
+        id: se.plural.toLowerCase(),
+        label: se.plural,
+        description: se.plural,
+        icon: 'file-text',
+        entity: st,
+        layouts: ['editor'],
+        defaultLayout: 'editor'
+      });
+    } else if (hasStatus && !leafType) {
+      // No hierarchy → standalone with status becomes primary board
+      tabs.push({
+        id: se.plural.toLowerCase(),
+        label: se.plural,
+        description: se.plural,
+        icon: 'check-square',
+        entity: st,
+        layouts: ['board', 'table', 'list'],
+        defaultLayout: 'board',
+        board: { groupBy: 'status', cardFields: ['id', 'title', 'status'], dragAction: 'update-status' },
+        table: { columns: ['id', 'title', 'status', 'assigned'], sortable: true },
+        filters: 'auto'
+      });
+    } else if (hasStatus) {
+      // Standalone with status in hierarchy preset → cards
+      tabs.push({
+        id: se.plural.toLowerCase(),
+        label: se.plural,
+        description: se.plural,
+        icon: 'alert-circle',
+        entity: st,
+        layouts: ['cards'],
+        defaultLayout: 'cards',
+        cards: { fields: ['title', 'status'], showContent: true },
+        filters: ['status']
+      });
+    }
+  }
+
+  // Metrics tab always last
+  var metricsCards = [];
+  if (rootType) {
+    metricsCards.push({ title: capitalize(entities.entities[rootType].singular) + ' Progress', type: 'progress-by-parent', parent: rootType });
+  }
+  if (leafType) {
+    metricsCards.push({ title: 'Status Breakdown', type: 'status-breakdown', entity: leafType });
+  } else if (standaloneTypes.length > 0) {
+    var primary = standaloneTypes.find(function (t) { return entities.entities[t] && entities.entities[t].fields && entities.entities[t].fields.status; });
+    if (primary) {
+      metricsCards.push({ title: 'Status Breakdown', type: 'status-breakdown', entity: primary });
+    }
+  }
+  metricsCards.push({ title: 'Project Health', type: 'health' });
+
+  tabs.push({
+    id: 'metrics',
+    label: 'Metrics',
+    description: 'Project progress and health overview',
+    icon: 'bar-chart',
+    layouts: ['metrics'],
+    defaultLayout: 'metrics',
+    metrics: { cards: metricsCards }
+  });
+
+  return {
+    tabs: tabs,
+    panel: { enabled: true, position: 'right', editableFields: 'auto', sections: ['properties', 'ai', 'content'] },
+    sourceRail: { enabled: true, position: 'left', showHome: true, showHistory: true }
+  };
+}
+
+function deriveDocsConfig(entities, structure) {
+  var leafType = findLeafType(structure);
+  var rootType = findRootType(structure);
+
+  var metrics = [];
+  if (rootType) {
+    metrics.push({ label: capitalize(entities.entities[rootType].plural), compute: 'count', entity: rootType });
+  }
+  if (leafType) {
+    metrics.push({ label: capitalize(entities.entities[leafType].plural), compute: 'count', entity: leafType, detail: 'done-ratio' });
+  } else {
+    // Kanban-style: use standalone with status
+    var standalone = Object.keys(structure.standalone || {});
+    for (var i = 0; i < standalone.length; i++) {
+      var e = entities.entities[standalone[i]];
+      if (e && e.fields && e.fields.status) {
+        metrics.push({ label: capitalize(e.plural), compute: 'count', entity: standalone[i], detail: 'done-ratio' });
+        break;
+      }
+    }
+  }
+
+  var sections = [{ type: 'summary', metrics: metrics }];
+
+  if (rootType) {
+    sections.push({ type: 'entity-list', entity: rootType, fields: ['title', 'status', 'progress'] });
+  }
+
+  var tableEntity = leafType || findPrimaryStandalone(entities, structure);
+  if (tableEntity) {
+    sections.push({ type: 'entity-table', entity: tableEntity, groupBy: 'status', fields: ['id', 'title', 'status'] });
+  }
+
+  return {
+    status: {
+      output: 'status.md',
+      header: 'Project Status: {{project.name}}',
+      sections: sections
+    }
+  };
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────
+
+function flattenHierarchyTypes(structure) {
+  var types = [];
+  function walk(node) {
+    for (var type in node) {
+      types.push(type);
+      if (node[type].children) walk(node[type].children);
+    }
+  }
+  walk(structure.hierarchy || {});
+  return types;
+}
+
+function findLeafType(structure) {
+  var types = flattenHierarchyTypes(structure);
+  return types.length > 0 ? types[types.length - 1] : null;
+}
+
+function findRootType(structure) {
+  var types = flattenHierarchyTypes(structure);
+  return types.length > 0 ? types[0] : null;
+}
+
+function findMidType(structure) {
+  var types = flattenHierarchyTypes(structure);
+  return types.length > 1 ? types[1] : null;
+}
+
+function findPrimaryStandalone(entities, structure) {
+  var standalone = Object.keys(structure.standalone || {});
+  for (var i = 0; i < standalone.length; i++) {
+    var e = entities.entities[standalone[i]];
+    if (e && e.fields && e.fields.status) return standalone[i];
+  }
+  return standalone[0] || null;
+}
+
+function capitalize(s) { return s.charAt(0).toUpperCase() + s.slice(1); }
+
+function buildTableColumns(leafType, entities, hierarchyTypes) {
+  var cols = ['id', 'title'];
+  // Add parent types as columns
+  for (var i = hierarchyTypes.length - 2; i >= 0; i--) {
+    cols.push(hierarchyTypes[i]);
+  }
+  cols.push('status');
+  var fields = entities.entities[leafType].fields;
+  if (fields.points) cols.push('points');
+  if (fields.assigned) cols.push('assigned');
+  return cols;
+}
+
+function buildListFields(type, entities) {
+  var fields = ['title', 'status'];
+  var e = entities.entities[type];
+  if (e.fields.start_date) fields.push('start_date');
+  if (e.fields.end_date) fields.push('end_date');
+  fields.push('progress');
+  return fields;
+}
+
+// ── Write preset to disk ────────────────────────────────────────────
+
+function writePreset(presetDir, configs) {
+  fs.mkdirSync(presetDir, { recursive: true });
+  var files = ['entities', 'structure', 'cli', 'api', 'ui', 'docs'];
+  for (var i = 0; i < files.length; i++) {
+    fs.writeFileSync(
+      path.join(presetDir, files[i] + '.json'),
+      JSON.stringify(configs[files[i]], null, 2) + '\n',
+      'utf-8'
+    );
+  }
+}
+
+// ── Subcommands ─────────────────────────────────────────────────────
+
+function listPresets() {
+  var presets = [];
+  try {
+    presets = fs.readdirSync(configEngine.PRESETS_DIR).filter(function (d) {
+      return fs.statSync(path.join(configEngine.PRESETS_DIR, d)).isDirectory();
+    });
+  } catch (e) { /* */ }
+
+  var builtIn = Object.keys(TEMPLATES);
+
+  console.log('\n  Available presets:\n');
+  for (var i = 0; i < presets.length; i++) {
+    var tag = builtIn.indexOf(presets[i]) !== -1 ? '' : '';
+    console.log('    ' + presets[i] + tag);
+  }
+
+  // Show templates not yet created
+  for (var j = 0; j < builtIn.length; j++) {
+    if (presets.indexOf(builtIn[j]) === -1) {
+      console.log('    ' + builtIn[j] + '  (template — run `mdboard preset create ' + builtIn[j] + '`)');
+    }
+  }
+  console.log('');
+}
+
+function createPreset(name, fromPreset) {
+  var presetDir = path.join(configEngine.PRESETS_DIR, name);
+
+  if (fs.existsSync(presetDir)) {
+    console.error('  Error: preset "' + name + '" already exists at ' + presetDir);
+    console.error('  Delete it first or choose a different name.');
+    process.exit(1);
+  }
+
+  var configs;
+
+  if (fromPreset) {
+    // Copy from existing preset
+    var sourceDir = path.join(configEngine.PRESETS_DIR, fromPreset);
+    if (!fs.existsSync(sourceDir)) {
+      console.error('  Error: source preset "' + fromPreset + '" not found.');
+      process.exit(1);
+    }
+    configs = {};
+    var files = ['entities', 'structure', 'cli', 'api', 'ui', 'docs'];
+    for (var i = 0; i < files.length; i++) {
+      var fp = path.join(sourceDir, files[i] + '.json');
+      try {
+        configs[files[i]] = JSON.parse(fs.readFileSync(fp, 'utf-8'));
+      } catch (e) {
+        configs[files[i]] = {};
+      }
+    }
+    // Update methodology name
+    if (configs.entities) configs.entities.methodology = name;
+  } else if (TEMPLATES[name]) {
+    // Built-in template with auto-derivation
+    var template = TEMPLATES[name]();
+    configs = {
+      entities:  template.entities,
+      structure: template.structure,
+      cli:       deriveCliConfig(template.entities, template.structure),
+      api:       deriveApiConfig(template.entities, template.structure),
+      ui:        deriveUiConfig(template.entities, template.structure),
+      docs:      deriveDocsConfig(template.entities, template.structure)
+    };
+  } else {
+    console.error('  Error: no built-in template for "' + name + '".');
+    console.error('  Use --from <preset> to copy an existing one.');
+    console.error('  Built-in templates: ' + Object.keys(TEMPLATES).join(', '));
+    process.exit(1);
+  }
+
+  writePreset(presetDir, configs);
+
+  // Output
+  var files = fs.readdirSync(presetDir).filter(function (f) { return f.endsWith('.json'); });
+  console.log('\n  Preset created: ' + name);
+  console.log('  Path: ' + presetDir + '/\n');
+  console.log('  Files:');
+  for (var j = 0; j < files.length; j++) {
+    console.log('    ' + files[j]);
+  }
+  console.log('\n  Edit any file to customize. Core files:');
+  console.log('    entities.json    Entity types, fields, statuses');
+  console.log('    structure.json   Directory layout & hierarchy');
+  console.log('  Derived (auto-generated from entities + structure):');
+  console.log('    cli.json, api.json, ui.json, docs.json\n');
+  console.log('  Use this preset:');
+  console.log('    mdboard --preset ' + name);
+  console.log('    mdboard preset show ' + name);
+  console.log('');
+}
+
+function showPreset(name) {
+  var presetDir = path.join(configEngine.PRESETS_DIR, name);
+  if (!fs.existsSync(presetDir)) {
+    console.error('  Error: preset "' + name + '" not found.');
+    if (TEMPLATES[name]) {
+      console.error('  Run `mdboard preset create ' + name + '` to generate it.');
+    }
+    process.exit(1);
+  }
+
+  var entitiesFile = path.join(presetDir, 'entities.json');
+  var structureFile = path.join(presetDir, 'structure.json');
+  var entities, structure;
+
+  try { entities = JSON.parse(fs.readFileSync(entitiesFile, 'utf-8')); } catch (e) { entities = {}; }
+  try { structure = JSON.parse(fs.readFileSync(structureFile, 'utf-8')); } catch (e) { structure = {}; }
+
+  var hierarchyTypes = flattenHierarchyTypes(structure);
+  var standaloneTypes = Object.keys(structure.standalone || {});
+  var allTypes = Object.keys(entities.entities || {});
+
+  console.log('\n  Preset: ' + name);
+  console.log('  Path:   ' + presetDir + '/');
+
+  // Hierarchy
+  if (hierarchyTypes.length > 0) {
+    var chain = hierarchyTypes.map(function (t) {
+      var e = entities.entities[t];
+      return e ? e.singular : t;
+    }).join(' > ');
+    console.log('\n  Hierarchy: ' + chain);
+  } else {
+    console.log('\n  Hierarchy: (flat — no nesting)');
+  }
+
+  // Standalone
+  if (standaloneTypes.length > 0) {
+    var names = standaloneTypes.map(function (t) {
+      var e = entities.entities[t];
+      return e ? e.singular : t;
+    }).join(', ');
+    console.log('  Standalone: ' + names);
+  }
+
+  // Entity details
+  console.log('\n  Entities (' + allTypes.length + '):\n');
+  for (var i = 0; i < allTypes.length; i++) {
+    var type = allTypes[i];
+    var e = entities.entities[type];
+    var statuses = e.fields && e.fields.status
+      ? e.fields.status.values.map(function (v) { return v.key; }).join(', ')
+      : '(no status)';
+    var storage = e.file === 'PREFIX-NNN.md' ? 'file' : 'dir';
+    console.log('    ' + e.prefix.padEnd(6) + ' ' + e.singular.padEnd(10) + ' [' + storage + ']  ' + statuses);
+  }
+
+  console.log('');
+}
+
+// ── CLI runner ──────────────────────────────────────────────────────
+
+function run(args) {
+  var subCmd = args[0];
+
+  if (!subCmd || subCmd === '--help' || subCmd === '-h') {
+    printHelp();
+    return;
+  }
+
+  if (subCmd === 'list') {
+    listPresets();
+    return;
+  }
+
+  if (subCmd === 'create') {
+    var name = args[1];
+    if (!name) {
+      console.error('  Error: preset name required.');
+      console.error('  Usage: mdboard preset create <name> [--from <preset>]');
+      process.exit(1);
+    }
+
+    var fromPreset = null;
+    for (var i = 2; i < args.length; i++) {
+      if (args[i] === '--from' && args[i + 1]) {
+        fromPreset = args[i + 1];
+      }
+    }
+
+    createPreset(name, fromPreset);
+    return;
+  }
+
+  if (subCmd === 'show') {
+    var name = args[1];
+    if (!name) {
+      console.error('  Error: preset name required.');
+      console.error('  Usage: mdboard preset show <name>');
+      process.exit(1);
+    }
+    showPreset(name);
+    return;
+  }
+
+  console.error('  Unknown subcommand: ' + subCmd);
+  printHelp();
+  process.exit(1);
+}
+
+function printHelp() {
+  console.log('\n  mdboard preset — Create and manage methodology presets\n');
+  console.log('  Subcommands:');
+  console.log('    mdboard preset list                    List available presets');
+  console.log('    mdboard preset create <name>           Create from built-in template');
+  console.log('    mdboard preset create <name> --from X  Copy existing preset');
+  console.log('    mdboard preset show <name>             Show preset summary\n');
+  console.log('  Built-in templates: ' + Object.keys(TEMPLATES).join(', '));
+  console.log('');
+}
+
+module.exports = { run, TEMPLATES, deriveCliConfig, deriveApiConfig, deriveUiConfig, deriveDocsConfig };