mdboard 1.2.0 → 2.0.0

package/presets/shape-up/entities.json

@@ -0,0 +1,140 @@
+{
+  "methodology": "shape-up",
+  "entities": {
+    "cycle": {
+      "singular": "Cycle",
+      "plural": "Cycles",
+      "prefix": "CYC",
+      "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": "cooldown",  "label": "Cooldown",  "color": "#D4A72C", "icon": "pause-circle" },
+            { "key": "completed", "label": "Completed", "color": "#2EA043", "icon": "check-circle" }
+          ],
+          "default": "planned"
+        },
+        "goal":       { "type": "string",  "label": "Goal" },
+        "duration":   { "type": "number",  "label": "Weeks", "default": 6 },
+        "start_date": { "type": "date",    "label": "Start" },
+        "end_date":   { "type": "date",    "label": "End" }
+      }
+    },
+    "bet": {
+      "singular": "Bet",
+      "plural": "Bets",
+      "prefix": "BET",
+      "file": "README.md",
+      "fields": {
+        "status": {
+          "type": "enum",
+          "values": [
+            { "key": "shaping",  "label": "Shaping",  "color": "#8B8B93", "icon": "dashed-circle" },
+            { "key": "ready",    "label": "Ready",    "color": "#06B6D4", "icon": "circle" },
+            { "key": "building", "label": "Building", "color": "#D4A72C", "icon": "half-circle" },
+            { "key": "shipped",  "label": "Shipped",  "color": "#2EA043", "icon": "check-circle" },
+            { "key": "dropped",  "label": "Dropped",  "color": "#5A5A63", "icon": "slash-circle" }
+          ],
+          "default": "shaping"
+        },
+        "appetite": {
+          "type": "enum",
+          "values": [
+            { "key": "small", "label": "Small Batch", "color": "#06B6D4" },
+            { "key": "big",   "label": "Big Batch",   "color": "#8B5CF6" }
+          ],
+          "default": "big"
+        },
+        "problem":  { "type": "text", "label": "Problem" },
+        "solution": { "type": "text", "label": "Solution" },
+        "no_gos":   { "type": "list", "label": "No-gos" }
+      }
+    },
+    "scope": {
+      "singular": "Scope",
+      "plural": "Scopes",
+      "prefix": "SCP",
+      "file": "README.md",
+      "fields": {
+        "hill": {
+          "type": "enum",
+          "values": [
+            { "key": "unknown",           "label": "Unknown",          "color": "#5A5A63", "icon": "circle" },
+            { "key": "figuring-out",      "label": "Figuring it out",  "color": "#F97316", "icon": "half-circle" },
+            { "key": "making-it-happen",  "label": "Making it happen", "color": "#5B6EF5", "icon": "three-quarter-circle" },
+            { "key": "done",              "label": "Done",             "color": "#2EA043", "icon": "check-circle" }
+          ],
+          "default": "unknown"
+        }
+      }
+    },
+    "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" },
+        "linked":   { "type": "ref",    "label": "Linked", "entity": "task", "multiple": true }
+      }
+    },
+    "pitch": {
+      "singular": "Pitch",
+      "plural": "Pitches",
+      "prefix": "PITCH",
+      "file": "PREFIX-NNN.md",
+      "fields": {
+        "status": {
+          "type": "enum",
+          "values": [
+            { "key": "draft",    "label": "Draft",    "color": "#5A5A63", "icon": "dashed-circle" },
+            { "key": "ready",    "label": "Ready",    "color": "#06B6D4", "icon": "circle" },
+            { "key": "accepted", "label": "Accepted", "color": "#2EA043", "icon": "check-circle" },
+            { "key": "rejected", "label": "Rejected", "color": "#DA3633", "icon": "x-circle" }
+          ],
+          "default": "draft"
+        },
+        "appetite": {
+          "type": "enum",
+          "values": [
+            { "key": "small", "label": "Small Batch", "color": "#06B6D4" },
+            { "key": "big",   "label": "Big Batch",   "color": "#8B5CF6" }
+          ],
+          "default": "big"
+        },
+        "problem":  { "type": "text", "label": "Problem" },
+        "solution": { "type": "text", "label": "Solution" },
+        "no_gos":   { "type": "list", "label": "No-gos" }
+      }
+    },
+    "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", "shipped", "completed"]
+}

package/presets/shape-up/structure.json

@@ -0,0 +1,28 @@
+{
+  "root": "project",
+  "hierarchy": {
+    "cycle": {
+      "dir": "cycles",
+      "children": {
+        "bet": {
+          "dir": "bets",
+          "children": {
+            "scope": {
+              "dir": "scopes",
+              "children": {
+                "task": { "dir": "tasks" }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "standalone": {
+    "pitch": { "dir": "pitches" },
+    "note":  { "dir": "notes" }
+  },
+  "archive": {
+    "dir": "archive"
+  }
+}

package/presets/shape-up/ui.json

@@ -0,0 +1,114 @@
+{
+  "tabs": [
+    {
+      "id": "tasks",
+      "label": "Tasks",
+      "description": "Individual work items to be completed",
+      "icon": "check-square",
+      "entity": "task",
+      "layouts": ["list", "board", "table"],
+      "defaultLayout": "board",
+      "board": {
+        "groupBy": "status",
+        "cardFields": ["id", "title", "points", "assigned"],
+        "dragAction": "update-status"
+      },
+      "table": {
+        "columns": ["id", "title", "scope", "bet", "cycle", "status", "points", "assigned"],
+        "sortable": true
+      },
+      "filters": "auto"
+    },
+    {
+      "id": "bets",
+      "label": "Bets",
+      "description": "Shaped projects with a fixed time appetite",
+      "icon": "target",
+      "entity": "bet",
+      "layouts": ["cards", "list"],
+      "defaultLayout": "cards",
+      "cards": {
+        "fields": ["title", "status", "appetite"],
+        "showProgress": true,
+        "expandChildren": {
+          "entity": "scope",
+          "fields": ["title", "hill"],
+          "showProgress": true
+        }
+      },
+      "list": {
+        "fields": ["title", "status", "appetite", "progress"],
+        "expandable": true
+      },
+      "filters": ["cycle", "status", "appetite"]
+    },
+    {
+      "id": "cycles",
+      "label": "Cycles",
+      "description": "Fixed time periods for betting and building",
+      "icon": "refresh-cw",
+      "entity": "cycle",
+      "layouts": ["list"],
+      "defaultLayout": "list",
+      "list": {
+        "fields": ["title", "status", "duration", "start_date", "end_date", "progress"],
+        "expandChildren": {
+          "entity": "bet",
+          "fields": ["title", "status", "appetite"]
+        }
+      },
+      "filters": ["status"]
+    },
+    {
+      "id": "pitches",
+      "label": "Pitches",
+      "description": "Ideas shaped into concrete proposals",
+      "icon": "lightbulb",
+      "entity": "pitch",
+      "layouts": ["cards"],
+      "defaultLayout": "cards",
+      "cards": {
+        "fields": ["title", "status", "appetite"],
+        "showContent": true
+      },
+      "filters": ["status", "appetite"]
+    },
+    {
+      "id": "notes",
+      "label": "Notes",
+      "description": "Freeform notes and documentation",
+      "icon": "file-text",
+      "entity": "note",
+      "layouts": ["editor"],
+      "defaultLayout": "editor"
+    },
+    {
+      "id": "metrics",
+      "label": "Metrics",
+      "description": "Project progress, health, and status overview",
+      "icon": "bar-chart",
+      "layouts": ["metrics"],
+      "defaultLayout": "metrics",
+      "metrics": {
+        "cards": [
+          { "title": "Cycle Progress",       "type": "progress-by-parent", "parent": "cycle" },
+          { "title": "Hill Chart",            "type": "hill-chart",         "entity": "scope" },
+          { "title": "Status Breakdown",      "type": "status-breakdown",   "entity": "task" },
+          { "title": "Project Health",        "type": "health" }
+        ]
+      }
+    }
+  ],
+  "panel": {
+    "enabled": true,
+    "position": "right",
+    "editableFields": "auto",
+    "sections": ["properties", "ai", "content"]
+  },
+  "sourceRail": {
+    "enabled": true,
+    "position": "left",
+    "showHome": true,
+    "showHistory": true
+  }
+}

package/src/cli/cli.js

@@ -0,0 +1,338 @@
+/**
+ * mdboard — Dynamic CLI utilities + CRUD handlers
+ *
+ * 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 configEngine = require('../core/config');
+const {
+  createModel, scanSource, computeProgress, mergeResults,
+  createEntity, updateEntity, deleteEntity,
+} = require('../core/scanner');
+
+// --- Build model ---
+
+/**
+ * Build the full project model from disk.
+ *
+ * @param {string} projectDir - Workspace root directory
+ * @returns {{ model, config, projectPath }}
+ */
+function buildModel(projectDir) {
+  const projectPath = path.join(projectDir, 'project');
+  const cfg = configEngine.loadConfig(projectDir, process.env.MDBOARD_CONFIG);
+  const model = createModel(cfg);
+
+  mergeResults(model, [scanSource(projectPath, cfg, {})]);
+  computeProgress(model, cfg);
+
+  return { model, config: cfg, projectPath };
+}
+
+// --- Flag parsing ---
+
+const GLOBAL_FLAGS = new Set(['project', 'config', 'workspace', 'preset']);
+
+/**
+ * Parse CLI flags and positional arguments.
+ */
+function parseFlags(args) {
+  const flags = {};
+  const positional = [];
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i].startsWith('--')) {
+      const key = args[i].slice(2);
+      const next = args[i + 1];
+      if (GLOBAL_FLAGS.has(key)) {
+        if (next && !next.startsWith('--')) i++;
+        continue;
+      }
+      if (next && !next.startsWith('--')) {
+        flags[key] = next;
+        i++;
+      } else {
+        flags[key] = true;
+      }
+    } else {
+      positional.push(args[i]);
+    }
+  }
+
+  return { flags, positional };
+}
+
+/**
+ * Resolve the project directory from args.
+ */
+function resolveProjectDir(args) {
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--project' && args[i + 1]) {
+      return path.resolve(args[i + 1]);
+    }
+  }
+  return process.cwd();
+}
+
+// --- Dynamic CRUD ---
+
+/**
+ * mdboard create <entity> <title> [--flags]
+ *
+ * Entities and flags are resolved dynamically from config.
+ */
+function handleCreate(projectDir, args) {
+  const { flags, positional } = parseFlags(args);
+  const entityType = positional[0];
+  const title = positional.slice(1).join(' ');
+
+  const { model, config: cfg, projectPath } = buildModel(projectDir);
+  const availableTypes = configEngine.getEntityTypes(cfg);
+
+  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);
+  }
+
+  if (!availableTypes.includes(entityType)) {
+    console.error('  Error: unknown entity "' + entityType + '". Available: ' + availableTypes.join(', '));
+    process.exit(1);
+  }
+
+  const entityDef = configEngine.getEntity(cfg, entityType);
+
+  // 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);
+  }
+
+  // Build data from flags + title
+  const data = { title };
+
+  // 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];
+  }
+
+  // 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);
+}
+
+/**
+ * mdboard update <entity> <id> [--key value ...]
+ */
+function handleUpdate(projectDir, args) {
+  const { flags, positional } = parseFlags(args);
+  const entityType = positional[0];
+  const id = positional[1];
+
+  const { model, config: cfg, projectPath } = buildModel(projectDir);
+  const availableTypes = configEngine.getEntityTypes(cfg);
+
+  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);
+  }
+
+  if (!availableTypes.includes(entityType)) {
+    console.error('  Error: unknown entity "' + entityType + '". Available: ' + availableTypes.join(', '));
+    process.exit(1);
+  }
+
+  const items = model.entities[entityType] || [];
+  const item = items.find(x => x.id === id) || items.find(x => x._originalId === id);
+
+  if (!item) {
+    console.error('  Error: ' + entityType + ' "' + id + '" not found');
+    process.exit(1);
+  }
+
+  if (Object.keys(flags).length === 0) {
+    console.error('  Error: no fields to update. Use --key value flags.');
+    process.exit(1);
+  }
+
+  // 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;
+    }
+  }
+
+  updateEntity(projectPath, item._file, updates);
+  console.log('  Updated ' + entityType + ' ' + id + ': ' + item._file);
+}
+
+/**
+ * mdboard delete <entity> <id>
+ */
+function handleDelete(projectDir, args) {
+  const { positional } = parseFlags(args);
+  const entityType = positional[0];
+  const id = positional[1];
+
+  const { model, config: cfg, projectPath } = buildModel(projectDir);
+  const availableTypes = configEngine.getEntityTypes(cfg);
+
+  if (!entityType || !id) {
+    console.log('\n  mdboard delete — Delete an entity\n\n  Usage:\n    mdboard delete <entity> <id>\n');
+    process.exit(1);
+  }
+
+  if (!availableTypes.includes(entityType)) {
+    console.error('  Error: unknown entity "' + entityType + '". Available: ' + availableTypes.join(', '));
+    process.exit(1);
+  }
+
+  const items = model.entities[entityType] || [];
+  const item = items.find(x => x.id === id) || items.find(x => x._originalId === id);
+
+  if (!item) {
+    console.error('  Error: ' + entityType + ' "' + id + '" not found');
+    process.exit(1);
+  }
+
+  deleteEntity(projectPath, item);
+  console.log('  Deleted ' + entityType + ' ' + id + ': ' + item._file);
+
+  // 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' : '') + '.');
+  }
+}
+
+/**
+ * Clean up dangling references after deleting an entity.
+ * Dynamically checks all ref fields across all entity types.
+ */
+function cleanReferences(projectPath, model, cfg, deletedType, deletedItem) {
+  let cleaned = 0;
+  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++;
+        }
+      }
+    }
+  }
+
+  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 (!availableTypes.includes(entityType)) {
+    console.error('  Error: unknown entity "' + entityType + '". Available: ' + availableTypes.join(', '));
+    process.exit(1);
+  }
+
+  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, handleList, cleanReferences,
+};