mdboard 1.3.0 → 2.1.0

package/src/cli/cli.js

@@ -1,70 +1,46 @@
 /**
- * mdboard — CLI utilities + CRUD handlers
+ * mdboard — Dynamic CLI utilities + CRUD handlers
  *
- * Provides buildModel() for shared use by status/sync/CRUD,
- * parseFlags() for CLI argument parsing, and
- * create/update/delete handlers with reference cleanup.
+ * All entity types, flags, and paths are resolved from config.
+ * No hardcoded entity names.
  */
 
+'use strict';
+
 const fs = require('fs');
 const path = require('path');
-const { loadConfig } = require('../core/config');
-const { loadWorkspace } = require('../core/workspace');
+const configEngine = require('../core/config');
 const {
   createModel, scanSource, computeProgress, mergeResults,
-  updateMarkdownFile, createTask, createMilestone, createEpic,
-  createSprint, archiveItem,
+  createEntity, updateEntity, deleteEntity,
 } = require('../core/scanner');
-const { parseFrontmatter, serializeYaml } = require('../core/yaml');
+
+// --- Build model ---
 
 /**
  * Build the full project model from disk.
  *
  * @param {string} projectDir - Workspace root directory
- * @returns {{ model, config, projectPath, workspace, sources }}
+ * @returns {{ model, config, projectPath }}
  */
 function buildModel(projectDir) {
   const projectPath = path.join(projectDir, 'project');
-  const config = loadConfig(projectDir, process.env.MDBOARD_CONFIG);
-  const wsPath = process.env.MDBOARD_WORKSPACE || null;
-  const workspace = loadWorkspace(projectDir, wsPath);
-  const sources = workspace ? workspace.sources : [];
-
-  const model = createModel();
-
-  if (workspace && sources.length > 0) {
-    const results = [];
-    for (const source of sources) {
-      const sourcePath = source._resolvedPath;
-      if (!sourcePath) continue;
-      const readonly = source.readonly != null ? source.readonly : (source.type === 'remote');
-      const meta = {
-        name: source.name,
-        label: source.label || source.name,
-        color: source.color || null,
-        type: source.type,
-        readonly,
-      };
-      results.push(scanSource(sourcePath, config, meta));
-    }
-    mergeResults(model, results);
-  } else {
-    mergeResults(model, [scanSource(projectPath, config, {})]);
-  }
+  const cfg = configEngine.loadConfig(projectDir, process.env.MDBOARD_CONFIG);
+  const model = createModel(cfg);
 
-  computeProgress(model, config.completedStatus);
+  mergeResults(model, [scanSource(projectPath, cfg, {})]);
+  computeProgress(model, cfg);
 
-  return { model, config, projectPath, workspace, sources };
+  return { model, config: cfg, projectPath };
 }
 
+// --- Flag parsing ---
+
+const GLOBAL_FLAGS = new Set(['project', 'config', 'workspace', 'preset']);
+
 /**
  * Parse CLI flags and positional arguments.
- *
- * @param {string[]} args - Raw CLI arguments
- * @returns {{ flags: object, positional: string[] }}
  */
-const GLOBAL_FLAGS = new Set(['project', 'config', 'workspace']);
-
 function parseFlags(args) {
   const flags = {};
   const positional = [];
@@ -74,7 +50,6 @@ function parseFlags(args) {
       const key = args[i].slice(2);
       const next = args[i + 1];
       if (GLOBAL_FLAGS.has(key)) {
-        // Skip global flags (consumed by resolveProjectDir / bin.js)
         if (next && !next.startsWith('--')) i++;
         continue;
       }
@@ -94,9 +69,6 @@ function parseFlags(args) {
 
 /**
  * Resolve the project directory from args.
- *
- * @param {string[]} args - Raw CLI arguments
- * @returns {string}
  */
 function resolveProjectDir(args) {
   for (let i = 0; i < args.length; i++) {
@@ -107,85 +79,82 @@ function resolveProjectDir(args) {
   return process.cwd();
 }
 
-// ═══════════════════════════════════════════════════════════════════════
-// CRUD handlers
-// ═══════════════════════════════════════════════════════════════════════
+// --- Dynamic CRUD ---
 
 /**
- * mdboard create <entity> <title> [flags]
+ * mdboard create <entity> <title> [--flags]
+ *
+ * Entities and flags are resolved dynamically from config.
  */
 function handleCreate(projectDir, args) {
   const { flags, positional } = parseFlags(args);
-  const entity = positional[0];
+  const entityType = positional[0];
   const title = positional.slice(1).join(' ');
 
-  if (!entity) {
-    console.log(`
-  mdboard create — Create a new entity
+  const { model, config: cfg, projectPath } = buildModel(projectDir);
+  const availableTypes = configEngine.getEntityTypes(cfg);
 
-  Usage:
-    mdboard create milestone <title>
-    mdboard create epic <title> --milestone <slug>
-    mdboard create task <title> --milestone <slug> --epic <slug> [--priority p] [--points n] [--sprint id]
-    mdboard create sprint --milestone <slug> [--goal "text"]
-`);
+  if (!entityType) {
+    const entityList = availableTypes.map(t => {
+      const e = configEngine.getEntity(cfg, t);
+      return '    mdboard create ' + t + ' "<title>"';
+    }).join('\n');
+
+    console.log('\n  mdboard create — Create a new entity\n\n  Usage:\n' + entityList + '\n');
     process.exit(1);
   }
 
-  const { model, config, projectPath } = buildModel(projectDir);
+  if (!availableTypes.includes(entityType)) {
+    console.error('  Error: unknown entity "' + entityType + '". Available: ' + availableTypes.join(', '));
+    process.exit(1);
+  }
 
-  switch (entity) {
-    case 'milestone': {
-      if (!title) { console.error('  Error: title is required'); process.exit(1); }
-      const result = createMilestone(projectPath, config, { title }, model.milestones);
-      console.log(`  Created milestone ${result.id}: ${result.file}`);
-      break;
-    }
+  const entityDef = configEngine.getEntity(cfg, entityType);
 
-    case 'epic': {
-      if (!title) { console.error('  Error: title is required'); process.exit(1); }
-      if (!flags.milestone) { console.error('  Error: --milestone is required'); process.exit(1); }
-      const result = createEpic(projectPath, config, {
-        title,
-        milestone: flags.milestone,
-      }, model.epics);
-      console.log(`  Created epic ${result.id}: ${result.file}`);
-      break;
-    }
+  // Check required title
+  if (!title && entityDef.file !== 'README.md') {
+    // File entities always need a title
+    console.error('  Error: title is required');
+    process.exit(1);
+  }
+  if (!title) {
+    console.error('  Error: title is required');
+    process.exit(1);
+  }
 
-    case 'task': {
-      if (!title) { console.error('  Error: title is required'); process.exit(1); }
-      if (!flags.milestone) { console.error('  Error: --milestone is required'); process.exit(1); }
-      if (!flags.epic) { console.error('  Error: --epic is required'); process.exit(1); }
-      const data = {
-        title,
-        milestone: flags.milestone,
-        epic: flags.epic,
-      };
-      if (flags.priority) data.priority = flags.priority;
-      if (flags.points) data.points = parseInt(flags.points, 10);
-      if (flags.sprint) data.sprint = flags.sprint;
-      if (flags.assigned) data.assigned = flags.assigned;
-      if (flags.status) data.status = flags.status;
-      const result = createTask(projectPath, config, data, model.tasks);
-      console.log(`  Created task ${result.id}: ${result.file}`);
-      break;
-    }
+  // Build data from flags + title
+  const data = { title };
 
-    case 'sprint': {
-      if (!flags.milestone) { console.error('  Error: --milestone is required'); process.exit(1); }
-      const data = { milestone: flags.milestone };
-      if (flags.goal) data.goal = flags.goal;
-      if (flags.status) data.status = flags.status;
-      const result = createSprint(projectPath, config, data, model.sprints);
-      console.log(`  Created sprint ${result.id}: ${result.file}`);
-      break;
+  // Add ancestor flags (required parent references)
+  const ancestors = configEngine.getAncestors(cfg, entityType);
+  for (const anc of ancestors) {
+    const flagName = anc.replace(/_/g, '-');
+    if (!flags[flagName] && !flags[anc]) {
+      console.error('  Error: --' + flagName + ' is required');
+      process.exit(1);
     }
+    data[anc] = flags[flagName] || flags[anc];
+  }
 
-    default:
-      console.error(`  Error: unknown entity "${entity}". Use: milestone, epic, task, sprint`);
-      process.exit(1);
+  // Add field flags
+  const fields = configEngine.getFields(cfg, entityType);
+  for (const [name, def] of Object.entries(fields)) {
+    const flagName = name.replace(/_/g, '-');
+    const val = flags[flagName] || flags[name];
+    if (val !== undefined) {
+      if (def.type === 'number') {
+        data[name] = parseInt(val, 10);
+      } else if (def.type === 'list') {
+        data[name] = typeof val === 'string' ? val.split(',') : val;
+      } else {
+        data[name] = val;
+      }
+    }
   }
+
+  const existing = model.entities[entityType] || [];
+  const result = createEntity(projectPath, cfg, entityType, data, existing);
+  console.log('  Created ' + entityDef.singular.toLowerCase() + ' ' + result.id + ': ' + result.file);
 }
 
 /**
@@ -193,42 +162,27 @@ function handleCreate(projectDir, args) {
  */
 function handleUpdate(projectDir, args) {
   const { flags, positional } = parseFlags(args);
-  const entity = positional[0];
+  const entityType = positional[0];
   const id = positional[1];
 
-  if (!entity || !id) {
-    console.log(`
-  mdboard update — Update an entity's frontmatter
+  const { model, config: cfg, projectPath } = buildModel(projectDir);
+  const availableTypes = configEngine.getEntityTypes(cfg);
 
-  Usage:
-    mdboard update task TASK-005 --status in-progress --assigned john
-    mdboard update milestone MS-001 --status active
-    mdboard update epic EPIC-002 --priority high
-    mdboard update sprint SP-003 --status active --goal "New goal"
-`);
+  if (!entityType || !id) {
+    console.log('\n  mdboard update — Update an entity\n\n  Usage:\n    mdboard update <entity> <id> --field value\n');
     process.exit(1);
   }
 
-  const { model, projectPath } = buildModel(projectDir);
-
-  const collectionMap = {
-    task: 'tasks',
-    milestone: 'milestones',
-    epic: 'epics',
-    sprint: 'sprints',
-  };
-
-  const collection = collectionMap[entity];
-  if (!collection) {
-    console.error(`  Error: unknown entity "${entity}". Use: task, milestone, epic, sprint`);
+  if (!availableTypes.includes(entityType)) {
+    console.error('  Error: unknown entity "' + entityType + '". Available: ' + availableTypes.join(', '));
     process.exit(1);
   }
 
-  const items = model[collection];
+  const items = model.entities[entityType] || [];
   const item = items.find(x => x.id === id) || items.find(x => x._originalId === id);
 
   if (!item) {
-    console.error(`  Error: ${entity} "${id}" not found`);
+    console.error('  Error: ' + entityType + ' "' + id + '" not found');
     process.exit(1);
   }
 
@@ -237,13 +191,25 @@ function handleUpdate(projectDir, args) {
     process.exit(1);
   }
 
-  // Convert numeric fields
-  const updates = { ...flags };
-  if (updates.points) updates.points = parseInt(updates.points, 10);
-  if (updates.planned_points) updates.planned_points = parseInt(updates.planned_points, 10);
+  // Convert types based on field definitions
+  const entityDef = configEngine.getEntity(cfg, entityType);
+  const fields = entityDef.fields || {};
+  const updates = {};
+
+  for (const [key, val] of Object.entries(flags)) {
+    const fieldName = key.replace(/-/g, '_');
+    const fieldDef = fields[fieldName];
+    if (fieldDef && fieldDef.type === 'number') {
+      updates[fieldName] = parseInt(val, 10);
+    } else if (fieldDef && fieldDef.type === 'list') {
+      updates[fieldName] = typeof val === 'string' ? val.split(',') : val;
+    } else {
+      updates[fieldName] = val;
+    }
+  }
 
-  updateMarkdownFile(projectPath, item._file, updates);
-  console.log(`  Updated ${entity} ${id}: ${item._file}`);
+  updateEntity(projectPath, item._file, updates);
+  console.log('  Updated ' + entityType + ' ' + id + ': ' + item._file);
 }
 
 /**
@@ -251,112 +217,122 @@ function handleUpdate(projectDir, args) {
  */
 function handleDelete(projectDir, args) {
   const { positional } = parseFlags(args);
-  const entity = positional[0];
+  const entityType = positional[0];
   const id = positional[1];
 
-  if (!entity || !id) {
-    console.log(`
-  mdboard delete — Delete an entity
+  const { model, config: cfg, projectPath } = buildModel(projectDir);
+  const availableTypes = configEngine.getEntityTypes(cfg);
 
-  Usage:
-    mdboard delete task TASK-005
-    mdboard delete sprint SP-003
-    mdboard delete epic EPIC-002
-    mdboard delete milestone MS-001
-`);
+  if (!entityType || !id) {
+    console.log('\n  mdboard delete — Delete an entity\n\n  Usage:\n    mdboard delete <entity> <id>\n');
     process.exit(1);
   }
 
-  const { model, config, projectPath } = buildModel(projectDir);
-
-  const collectionMap = {
-    task: 'tasks',
-    milestone: 'milestones',
-    epic: 'epics',
-    sprint: 'sprints',
-  };
-
-  const collection = collectionMap[entity];
-  if (!collection) {
-    console.error(`  Error: unknown entity "${entity}". Use: task, milestone, epic, sprint`);
+  if (!availableTypes.includes(entityType)) {
+    console.error('  Error: unknown entity "' + entityType + '". Available: ' + availableTypes.join(', '));
     process.exit(1);
   }
 
-  const items = model[collection];
+  const items = model.entities[entityType] || [];
   const item = items.find(x => x.id === id) || items.find(x => x._originalId === id);
 
   if (!item) {
-    console.error(`  Error: ${entity} "${id}" not found`);
+    console.error('  Error: ' + entityType + ' "' + id + '" not found');
     process.exit(1);
   }
 
-  archiveItem(projectPath, item);
-  console.log(`  Deleted ${entity} ${id}: ${item._file}`);
+  deleteEntity(projectPath, item);
+  console.log('  Deleted ' + entityType + ' ' + id + ': ' + item._file);
 
-  // Clean up references
-  const cleaned = cleanReferences(projectPath, model, config, entity, item);
+  // Clean ref fields pointing to this entity
+  const cleaned = cleanReferences(projectPath, model, cfg, entityType, item);
   if (cleaned > 0) {
-    console.log(`  Cleaned ${cleaned} reference${cleaned > 1 ? 's' : ''}.`);
+    console.log('  Cleaned ' + cleaned + ' reference' + (cleaned > 1 ? 's' : '') + '.');
   }
 }
 
 /**
  * Clean up dangling references after deleting an entity.
- *
- * @param {string} projectPath - Absolute path to project/ dir
- * @param {object} model - Current model
- * @param {object} config - Config object
- * @param {string} entity - Entity type deleted (task, sprint, epic)
- * @param {object} deletedItem - The deleted item
- * @returns {number} - Number of references cleaned
+ * Dynamically checks all ref fields across all entity types.
  */
-function cleanReferences(projectPath, model, config, entity, deletedItem) {
+function cleanReferences(projectPath, model, cfg, deletedType, deletedItem) {
   let cleaned = 0;
-  const deletedId = deletedItem.id;
-
-  if (entity === 'task') {
-    // Remove task from sprint.features[]
-    for (const sprint of model.sprints) {
-      if (sprint.features && Array.isArray(sprint.features) && sprint.features.includes(deletedId)) {
-        const newFeatures = sprint.features.filter(f => f !== deletedId);
-        updateMarkdownFile(projectPath, sprint._file, { features: newFeatures });
-        cleaned++;
+  const deletedId = deletedItem._originalId || deletedItem.id;
+
+  for (const type of configEngine.getEntityTypes(cfg)) {
+    const refs = configEngine.getRefFields(cfg, type);
+    for (const ref of refs) {
+      if (ref.targetEntity !== deletedType) continue;
+
+      const items = model.entities[type] || [];
+      for (const item of items) {
+        const val = item[ref.fieldName];
+        if (!val) continue;
+
+        if (ref.multiple && Array.isArray(val) && val.includes(deletedId)) {
+          const newVal = val.filter(v => v !== deletedId);
+          updateEntity(projectPath, item._file, { [ref.fieldName]: newVal });
+          cleaned++;
+        } else if (!ref.multiple && val === deletedId) {
+          updateEntity(projectPath, item._file, { [ref.fieldName]: null });
+          cleaned++;
+        }
       }
     }
   }
 
-  if (entity === 'sprint') {
-    // Clear task.sprint references
-    for (const task of model.tasks) {
-      if (task.sprint === deletedId) {
-        updateMarkdownFile(projectPath, task._file, { sprint: null });
-        cleaned++;
-      }
-    }
+  return cleaned;
+}
+
+/**
+ * mdboard list <entity> [--status xxx] [--cycle xxx]
+ */
+function handleList(projectDir, args) {
+  const { flags, positional } = parseFlags(args);
+  const entityType = positional[0];
+
+  const { model, config: cfg } = buildModel(projectDir);
+  const availableTypes = configEngine.getEntityTypes(cfg);
+
+  if (!entityType) {
+    console.log('\n  mdboard list — List entities\n\n  Available types: ' + availableTypes.join(', ') + '\n');
+    process.exit(1);
   }
 
-  if (entity === 'epic') {
-    // Clean epic.dependencies[] references
-    for (const epic of model.epics) {
-      if (epic.dependencies && Array.isArray(epic.dependencies) && epic.dependencies.includes(deletedId)) {
-        const newDeps = epic.dependencies.filter(d => d !== deletedId);
-        updateMarkdownFile(projectPath, epic._file, { dependencies: newDeps });
-        cleaned++;
-      }
-    }
-    // Warn about orphaned tasks
-    const orphanedTasks = model.tasks.filter(t =>
-      t._epic === deletedItem._dir && t._milestone === deletedItem._milestone
-    );
-    if (orphanedTasks.length > 0) {
-      console.log(`  Warning: ${orphanedTasks.length} task(s) under deleted epic may be orphaned.`);
-    }
+  if (!availableTypes.includes(entityType)) {
+    console.error('  Error: unknown entity "' + entityType + '". Available: ' + availableTypes.join(', '));
+    process.exit(1);
   }
 
-  return cleaned;
+  let items = model.entities[entityType] || [];
+
+  // Apply filters from flags
+  for (const [key, val] of Object.entries(flags)) {
+    const fieldName = key.replace(/-/g, '_');
+    items = items.filter(item => {
+      const itemVal = item[fieldName] || item['_' + fieldName];
+      if (Array.isArray(itemVal)) return itemVal.includes(val);
+      return itemVal === val;
+    });
+  }
+
+  const entityDef = configEngine.getEntity(cfg, entityType);
+
+  if (items.length === 0) {
+    console.log('\n  No ' + entityDef.plural.toLowerCase() + ' found.\n');
+    return;
+  }
+
+  console.log('\n  ' + entityDef.plural + ' (' + items.length + '):\n');
+  for (const item of items) {
+    const status = item.status ? ' [' + item.status + ']' : '';
+    const title = item.title || item.id || '(untitled)';
+    console.log('    ' + (item.id || '-') + '  ' + title + status);
+  }
+  console.log('');
 }
 
 module.exports = {
   buildModel, parseFlags, resolveProjectDir,
-  handleCreate, handleUpdate, handleDelete, cleanReferences,
+  handleCreate, handleUpdate, handleDelete, handleList, cleanReferences,
 };