@ktpartners/dgs-platform 2.6.2

package/deliver-great-systems/bin/lib/projects.cjs

@@ -0,0 +1,691 @@
+/**
+ * Projects — Project lifecycle: subfolder creation, state reading,
+ *             PROJECTS.md regeneration, repo tag scanning, project completion
+ *
+ * This module is the foundation for all Phase 3 commands: new-project,
+ * switch-project, list-projects, complete-project, and the projects CLI subcommand.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { safeReadFile, getProjectFolders, generateSlugInternal, isV2Install, output, error, loadConfig, getProjectDir } = require('./core.cjs');
+const { writeConfigField } = require('./config.cjs');
+const { getPlanningRoot } = require('./paths.cjs');
+
+// ─── Constants ──────────────────────────────────────────────────────────────
+
+const STANDARD_DIRS = ['phases', 'research', 'todos', 'quick', 'debug'];
+
+// ─── Project Subfolder Creation ─────────────────────────────────────────────
+
+/**
+ * Create a project subfolder under .planning/projects/<slug>/ with all standard
+ * planning files and directories.
+ *
+ * @param {string} cwd - Working directory (product root)
+ * @param {string} slug - Project slug (lowercase, hyphens, no special chars)
+ * @param {string} name - Human-readable project name
+ * @param {Object} [options] - Optional settings
+ * @param {string} [options.initial_repos] - Comma-separated initial repo names
+ * @returns {{ created: boolean, path?: string, reason?: string }}
+ */
+function createProjectSubfolder(cwd, slug, name, options) {
+  const projectDir = getProjectDir(cwd, slug);
+  // Ensure .planning/projects/ container exists
+  fs.mkdirSync(path.dirname(projectDir), { recursive: true });
+
+  // Don't overwrite existing project
+  if (fs.existsSync(projectDir)) {
+    return { created: false, reason: 'already_exists' };
+  }
+
+  // Create project directory
+  fs.mkdirSync(projectDir, { recursive: true });
+
+  // Create standard subdirectories
+  for (const dir of STANDARD_DIRS) {
+    fs.mkdirSync(path.join(projectDir, dir), { recursive: true });
+  }
+
+  // Create standard files with templates
+  const opts = options || {};
+
+  let projectMd = `# Project: ${name}\n\n## What This Is\n\n[Describe the project scope and goals]\n`;
+  if (opts.initial_repos) {
+    projectMd += `\n## Initial Repos\n\n${opts.initial_repos}\n`;
+  }
+  fs.writeFileSync(path.join(projectDir, 'PROJECT.md'), projectMd);
+
+  fs.writeFileSync(
+    path.join(projectDir, 'REQUIREMENTS.md'),
+    `# Requirements: ${name}\n\n## v1 Requirements\n\n`
+  );
+
+  fs.writeFileSync(
+    path.join(projectDir, 'ROADMAP.md'),
+    `# Roadmap: ${name}\n\n## Phases\n\n`
+  );
+
+  fs.writeFileSync(
+    path.join(projectDir, 'STATE.md'),
+    `# Project State\n\n## Current Position\n\nPhase: Not started\nStatus: New\nProgress: [░░░░░░░░░░] 0%\n`
+  );
+
+  return { created: true, path: projectDir };
+}
+
+// ─── Project State Reading ──────────────────────────────────────────────────
+
+/**
+ * Read and parse a project's STATE.md at .planning/projects/<slug>/STATE.md
+ * to extract status information.
+ *
+ * Extracts:
+ * - phase: From "Phase: ..." line
+ * - status: From "Status: ..." line
+ * - progress: From "Progress: [...] NN%" line (integer)
+ * - completed_date: From "Completed: YYYY-MM-DD" line
+ *
+ * @param {string} cwd - Working directory (product root)
+ * @param {string} slug - Project slug
+ * @returns {{ phase: string, status: string, progress: number, completed_date: string|null } | null}
+ */
+function readProjectState(cwd, slug) {
+  const statePath = path.join(getProjectDir(cwd, slug), 'STATE.md');
+  const content = safeReadFile(statePath);
+  if (!content) return null;
+
+  const phaseMatch = content.match(/Phase:\s*(.+)/i);
+  const statusMatch = content.match(/Status:\s*(.+)/i);
+  const progressMatch = content.match(/Progress:\s*\[[^\]]*\]\s*(\d+)%/);
+  const completedMatch = content.match(/Completed:\s*(\d{4}-\d{2}-\d{2})/);
+
+  return {
+    phase: phaseMatch ? phaseMatch[1].trim() : 'Unknown',
+    status: statusMatch ? statusMatch[1].trim() : 'Unknown',
+    progress: progressMatch ? parseInt(progressMatch[1], 10) : 0,
+    completed_date: completedMatch ? completedMatch[1] : null,
+  };
+}
+
+// ─── Repo Tag Scanning ──────────────────────────────────────────────────────
+
+/**
+ * Scan a project's plan files for <repos>...</repos> tags and extract
+ * all unique repo names referenced.
+ *
+ * Scans all PLAN.md files under .planning/projects/<slug>/phases/ subdirectories.
+ *
+ * @param {string} cwd - Working directory (product root)
+ * @param {string} slug - Project slug
+ * @returns {string[]} Sorted, deduplicated array of repo names
+ */
+function scanProjectReposTags(cwd, slug) {
+  const phasesDir = path.join(getProjectDir(cwd, slug), 'phases');
+  const allRepos = new Set();
+
+  try {
+    const phaseDirs = fs.readdirSync(phasesDir, { withFileTypes: true })
+      .filter(e => e.isDirectory())
+      .map(e => e.name);
+
+    for (const phaseDir of phaseDirs) {
+      const fullPhaseDir = path.join(phasesDir, phaseDir);
+      let planFiles;
+      try {
+        planFiles = fs.readdirSync(fullPhaseDir)
+          .filter(f => f.endsWith('-PLAN.md') || f === 'PLAN.md');
+      } catch {
+        continue;
+      }
+
+      for (const planFile of planFiles) {
+        const content = safeReadFile(path.join(fullPhaseDir, planFile));
+        if (!content) continue;
+
+        const matches = content.match(/<repos>([^<]+)<\/repos>/g);
+        if (!matches) continue;
+
+        for (const match of matches) {
+          const inner = match.replace(/<\/?repos>/g, '');
+          inner
+            .split(',')
+            .map(n => n.trim())
+            .filter(n => n)
+            .forEach(n => allRepos.add(n));
+        }
+      }
+    }
+  } catch {
+    // phases directory doesn't exist or other error
+  }
+
+  return Array.from(allRepos).sort();
+}
+
+// ─── PROJECTS.md Regeneration ───────────────────────────────────────────────
+
+/**
+ * Regenerate .planning/PROJECTS.md by scanning all project subfolders.
+ *
+ * Reads each project's STATE.md for status/phase/progress, scans plan
+ * <repos> tags for repos touched, and writes the derived PROJECTS.md.
+ *
+ * Ghost project guard: projects whose STATE.md is missing or unreadable
+ * are warned about and omitted from the output.
+ *
+ * @param {string} cwd - Working directory (product root)
+ * @returns {{ projects: Array, warnings: string[] }}
+ */
+function regenerateProjectsMd(cwd) {
+  const slugs = getProjectFolders(cwd);
+  const warnings = [];
+  const projects = [];
+
+  for (const slug of slugs) {
+    const state = readProjectState(cwd, slug);
+    if (!state) {
+      warnings.push(`Ghost project: ${slug} (STATE.md missing or unreadable)`);
+      continue;
+    }
+
+    const reposTouched = scanProjectReposTags(cwd, slug);
+    projects.push({
+      name: slug,
+      status: state.status,
+      repos_touched: reposTouched.join(', '),
+      current_phase: state.phase,
+      completed_date: state.completed_date || '',
+      progress: state.progress,
+    });
+  }
+
+  // Write PROJECTS.md
+  let content = '# Projects\n\n';
+  content += '## Active\n\n';
+  content += '| Project | Status | Repos Touched | Current Phase |\n';
+  content += '|---------|--------|---------------|---------------|\n';
+
+  const active = projects.filter(p => !p.status.toLowerCase().includes('completed'));
+  for (const proj of active) {
+    content += `| ${proj.name} | ${proj.status} | ${proj.repos_touched} | ${proj.current_phase} |\n`;
+  }
+
+  content += '\n## Completed\n\n';
+  content += '| Project | Completed | Duration |\n';
+  content += '|---------|-----------|----------|\n';
+
+  const completed = projects.filter(p => p.status.toLowerCase().includes('completed'));
+  for (const proj of completed) {
+    content += `| ${proj.name} | ${proj.completed_date} | |\n`;
+  }
+
+  fs.writeFileSync(path.join(getPlanningRoot(cwd), 'PROJECTS.md'), content);
+
+  return { projects, warnings };
+}
+
+// ─── Project Completion ─────────────────────────────────────────────────────
+
+/**
+ * Mark a project as completed by updating its STATE.md at
+ * .planning/projects/<slug>/STATE.md.
+ *
+ * - Updates "Status:" line to "completed"
+ * - Adds "Completed: YYYY-MM-DD" line with today's date
+ * - Preserves existing STATE.md content structure
+ *
+ * @param {string} cwd - Working directory (product root)
+ * @param {string} slug - Project slug
+ * @returns {{ completed: boolean, date?: string, error?: string }}
+ */
+function completeProject(cwd, slug) {
+  const projectDir = getProjectDir(cwd, slug);
+  const statePath = path.join(projectDir, 'STATE.md');
+
+  // Check project directory exists
+  if (!fs.existsSync(projectDir)) {
+    return { completed: false, error: 'not_found' };
+  }
+
+  // Check STATE.md exists
+  const content = safeReadFile(statePath);
+  if (!content) {
+    return { completed: false, error: 'no_state_md' };
+  }
+
+  // Check if already completed
+  if (/Status:\s*completed/i.test(content)) {
+    return { completed: false, error: 'already_completed' };
+  }
+
+  const today = new Date().toISOString().slice(0, 10);
+  let updated = content;
+
+  // Update or add Status line
+  if (/Status:\s*.+/i.test(updated)) {
+    updated = updated.replace(/Status:\s*.+/i, 'Status: completed');
+  } else {
+    updated += '\nStatus: completed\n';
+  }
+
+  // Add or update Completed date
+  if (/Completed:\s*\d{4}-\d{2}-\d{2}/.test(updated)) {
+    updated = updated.replace(/Completed:\s*\d{4}-\d{2}-\d{2}/, `Completed: ${today}`);
+  } else {
+    // Add after Status line
+    updated = updated.replace(/(Status: completed)/, `$1\nCompleted: ${today}`);
+  }
+
+  fs.writeFileSync(statePath, updated);
+
+  return { completed: true, date: today };
+}
+
+// ─── Project Reactivation ────────────────────────────────────────────────────
+
+/**
+ * Reactivate a completed project by updating its STATE.md at
+ * .planning/projects/<slug>/STATE.md.
+ *
+ * - Changes "Status: completed" back to "Status: In progress"
+ * - Removes the "Completed: YYYY-MM-DD" line entirely
+ * - Preserves all other STATE.md content
+ *
+ * @param {string} cwd - Working directory (product root)
+ * @param {string} slug - Project slug
+ * @returns {{ reactivated: boolean, error?: string }}
+ */
+function reactivateProject(cwd, slug) {
+  const projectDir = getProjectDir(cwd, slug);
+  const statePath = path.join(projectDir, 'STATE.md');
+
+  // Check project directory exists
+  if (!fs.existsSync(projectDir)) {
+    return { reactivated: false, error: 'not_found' };
+  }
+
+  // Check STATE.md exists
+  const content = safeReadFile(statePath);
+  if (!content) {
+    return { reactivated: false, error: 'no_state_md' };
+  }
+
+  // Check project IS completed
+  if (!/Status:\s*completed/i.test(content)) {
+    return { reactivated: false, error: 'not_completed' };
+  }
+
+  let updated = content;
+
+  // Change Status back to In progress
+  updated = updated.replace(/Status:\s*completed/i, 'Status: In progress');
+
+  // Remove the Completed date line entirely (including its trailing newline)
+  updated = updated.replace(/Completed:\s*\d{4}-\d{2}-\d{2}\n?/, '');
+
+  fs.writeFileSync(statePath, updated);
+
+  return { reactivated: true };
+}
+
+// ─── PROJECTS.md Parsing ────────────────────────────────────────────────────
+
+/**
+ * Parse .planning/PROJECTS.md into structured data.
+ *
+ * Returns null if the file doesn't exist or doesn't start with '# Projects'.
+ *
+ * @param {string} cwd - Working directory (product root)
+ * @returns {{ active: Array<{name, status, repos_touched, current_phase}>, completed: Array<{name, completed, duration}> } | null}
+ */
+function parseProjectsMd(cwd) {
+  const filePath = path.join(getPlanningRoot(cwd), 'PROJECTS.md');
+  const content = safeReadFile(filePath);
+  if (!content) return null;
+
+  // v2 marker check
+  if (!content.startsWith('# Projects')) return null;
+
+  const active = [];
+  const completed = [];
+
+  // Split into Active and Completed sections
+  const sections = content.split('## Completed');
+  const activeSection = sections[0] || '';
+  const completedSection = sections[1] || '';
+
+  // Parse Active table
+  const activeLines = activeSection.split('\n');
+  let inActiveTable = false;
+  for (const line of activeLines) {
+    if (line.startsWith('|') && line.includes('Project') && line.includes('Status')) {
+      inActiveTable = true;
+      continue;
+    }
+    if (inActiveTable && line.startsWith('|---')) {
+      continue;
+    }
+    if (inActiveTable && line.startsWith('|')) {
+      const cells = line.split('|').map(c => c.trim());
+      if (cells.length >= 5 && cells[1]) {
+        active.push({
+          name: cells[1],
+          status: cells[2],
+          repos_touched: cells[3],
+          current_phase: cells[4],
+        });
+      }
+    } else if (inActiveTable) {
+      inActiveTable = false;
+    }
+  }
+
+  // Parse Completed table
+  const completedLines = completedSection.split('\n');
+  let inCompletedTable = false;
+  for (const line of completedLines) {
+    if (line.startsWith('|') && line.includes('Project') && line.includes('Completed')) {
+      inCompletedTable = true;
+      continue;
+    }
+    if (inCompletedTable && line.startsWith('|---')) {
+      continue;
+    }
+    if (inCompletedTable && line.startsWith('|')) {
+      const cells = line.split('|').map(c => c.trim());
+      if (cells.length >= 4 && cells[1]) {
+        completed.push({
+          name: cells[1],
+          completed: cells[2],
+          duration: cells[3],
+        });
+      }
+    } else if (inCompletedTable) {
+      inCompletedTable = false;
+    }
+  }
+
+  return { active, completed };
+}
+
+// ─── Slug Prefix Collision Detection ─────────────────────────────────────────
+
+/**
+ * Check if a new project slug has a prefix collision with any existing slug.
+ *
+ * A prefix collision occurs when:
+ * - An existing slug is a prefix of the new slug (e.g., "api-v2" is prefix of "api-v2-hotfix")
+ * - The new slug is a prefix of an existing slug (e.g., "api" is prefix of "api-v2")
+ *
+ * @param {string} newSlug - The new project slug to check
+ * @param {string[]} existingSlugs - Array of existing project slugs
+ * @returns {{ collision: boolean, collidingSlug?: string }}
+ */
+function checkSlugPrefixCollision(newSlug, existingSlugs) {
+  for (const existing of existingSlugs) {
+    if (existing === newSlug) continue; // Exact match is handled by createProjectSubfolder
+    if (existing.startsWith(newSlug) || newSlug.startsWith(existing)) {
+      return { collision: true, collidingSlug: existing };
+    }
+  }
+  return { collision: false };
+}
+
+// ─── CLI Command Functions ───────────────────────────────────────────────────
+
+/**
+ * CLI: Create a new project subfolder and set it as the active project.
+ *
+ * - Requires v2 install
+ * - Generates slug from name
+ * - Creates subfolder with standard structure
+ * - Sets current_project in config.json
+ * - Regenerates PROJECTS.md
+ *
+ * @param {string} cwd - Working directory (product root)
+ * @param {string} name - Human-readable project name
+ * @param {Object} [options] - Optional settings
+ * @param {string} [options.initial_repos] - Comma-separated initial repo names
+ * @param {boolean} raw - Raw output mode
+ */
+function cmdProjectsCreate(cwd, name, options, raw) {
+  if (!isV2Install(cwd)) error('v2 install required. Run /dgs:init-product first.');
+  if (!name) error('Project name required. Usage: projects create <name>');
+
+  const slug = generateSlugInternal(name);
+  if (!slug) error('Invalid project name — could not generate slug.');
+
+  // Check for slug prefix collisions before creating
+  const existingSlugs = getProjectFolders(cwd);
+  const prefixCheck = checkSlugPrefixCollision(slug, existingSlugs);
+
+  const result = createProjectSubfolder(cwd, slug, name, options);
+  if (!result.created) {
+    error(`Project "${slug}" already exists.`);
+  }
+
+  writeConfigField(cwd, 'current_project', slug);
+  regenerateProjectsMd(cwd);
+
+  const outputData = { created: true, slug, name, path: result.path };
+  if (prefixCheck.collision) {
+    outputData.warning = `Slug '${slug}' shares prefix with existing project '${prefixCheck.collidingSlug}'. Branch names may be ambiguous.`;
+  }
+  output(outputData, raw);
+}
+
+/**
+ * CLI: Switch the active project context.
+ *
+ * - Requires v2 install
+ * - Matches by exact slug or case-insensitive partial match
+ * - Updates current_project in config.json
+ *
+ * @param {string} cwd - Working directory (product root)
+ * @param {string} name - Project slug or name to switch to
+ * @param {boolean} raw - Raw output mode
+ */
+function cmdProjectsSwitch(cwd, name, raw) {
+  if (!isV2Install(cwd)) error('v2 install required. Run /dgs:init-product first.');
+  if (!name) error('Project name required. Usage: projects switch <name>');
+
+  const projects = getProjectFolders(cwd);
+  if (projects.length === 0) {
+    error('No projects found. Create one first with: projects create <name>');
+  }
+
+  // Try exact slug match first
+  let matchedSlug = projects.find(p => p === name);
+
+  // Try case-insensitive match on slug
+  if (!matchedSlug) {
+    const lower = name.toLowerCase();
+    matchedSlug = projects.find(p => p.toLowerCase() === lower);
+  }
+
+  // Try slug generated from name
+  if (!matchedSlug) {
+    const generatedSlug = generateSlugInternal(name);
+    if (generatedSlug) {
+      matchedSlug = projects.find(p => p === generatedSlug);
+    }
+  }
+
+  if (!matchedSlug) {
+    error(`Project "${name}" not found. Available: ${projects.join(', ')}`);
+  }
+
+  // Guard: reject switching to completed projects
+  const state = readProjectState(cwd, matchedSlug);
+  if (state && state.status.toLowerCase().includes('completed')) {
+    error(`Project "${matchedSlug}" is completed. Use /dgs:reactivate-project to resume work on it.`);
+  }
+
+  writeConfigField(cwd, 'current_project', matchedSlug);
+
+  output({ switched: true, slug: matchedSlug, status: state }, raw);
+}
+
+/**
+ * CLI: List all projects with their status and repos touched.
+ *
+ * - Requires v2 install
+ * - Regenerates PROJECTS.md to ensure freshness
+ * - Returns active and completed project lists
+ *
+ * @param {string} cwd - Working directory (product root)
+ * @param {boolean} raw - Raw output mode
+ */
+function cmdProjectsList(cwd, raw) {
+  if (!isV2Install(cwd)) error('v2 install required. Run /dgs:init-product first.');
+
+  const result = regenerateProjectsMd(cwd);
+  const active = result.projects.filter(p => !p.status.toLowerCase().includes('completed'));
+  const completed = result.projects.filter(p => p.status.toLowerCase().includes('completed'));
+
+  output({ active, completed, warnings: result.warnings }, raw);
+}
+
+/**
+ * CLI: Mark a project as completed.
+ *
+ * - Requires v2 install
+ * - Uses options.slug or falls back to current_project from config
+ * - Marks project as completed in STATE.md
+ * - Clears current_project in config.json
+ * - Regenerates PROJECTS.md
+ * - Reports remaining active projects
+ *
+ * @param {string} cwd - Working directory (product root)
+ * @param {Object} options - Options
+ * @param {string} [options.slug] - Specific project slug to complete
+ * @param {boolean} raw - Raw output mode
+ */
+function cmdProjectsComplete(cwd, options, raw) {
+  if (!isV2Install(cwd)) error('v2 install required. Run /dgs:init-product first.');
+
+  const opts = options || {};
+  let slug = opts.slug;
+
+  if (!slug) {
+    const cfg = loadConfig(cwd);
+    slug = cfg.current_project;
+  }
+
+  if (!slug) {
+    error('No active project. Switch to one first with: projects switch <name>');
+  }
+
+  const result = completeProject(cwd, slug);
+  if (!result.completed) {
+    if (result.error === 'not_found') {
+      error(`Project "${slug}" not found.`);
+    } else if (result.error === 'no_state_md') {
+      error(`Project "${slug}" has no STATE.md file.`);
+    } else if (result.error === 'already_completed') {
+      error(`Project "${slug}" is already completed.`);
+    } else {
+      error(`Failed to complete project "${slug}": ${result.error}`);
+    }
+  }
+
+  const currentCfg = loadConfig(cwd);
+  if (currentCfg.current_project === slug) {
+    writeConfigField(cwd, 'current_project', null);
+  }
+  const regenResult = regenerateProjectsMd(cwd);
+  const remainingActive = regenResult.projects.filter(p => !p.status.toLowerCase().includes('completed'));
+
+  output({ completed: true, slug, date: result.date, remaining_active: remainingActive }, raw);
+}
+
+/**
+ * CLI: Reactivate a completed project.
+ *
+ * - Requires v2 install
+ * - Uses options.slug or falls back to current_project from config
+ * - Restores project status to "In progress" in STATE.md
+ * - Removes Completed date from STATE.md
+ * - Optionally sets the project as current_project in config.json
+ * - Regenerates PROJECTS.md
+ * - Reports remaining active projects
+ *
+ * @param {string} cwd - Working directory (product root)
+ * @param {Object} options - Options
+ * @param {string} [options.slug] - Specific project slug to reactivate
+ * @param {boolean} [options.set_current] - Set as current project after reactivation
+ * @param {boolean} raw - Raw output mode
+ */
+function cmdProjectsReactivate(cwd, options, raw) {
+  if (!isV2Install(cwd)) error('v2 install required. Run /dgs:init-product first.');
+
+  const opts = options || {};
+  let slug = opts.slug;
+
+  if (!slug) {
+    const cfg = loadConfig(cwd);
+    slug = cfg.current_project;
+  }
+
+  if (!slug) {
+    error('No active project. Use --slug <name> to specify which project to reactivate.');
+  }
+
+  const result = reactivateProject(cwd, slug);
+  if (!result.reactivated) {
+    if (result.error === 'not_found') {
+      error(`Project "${slug}" not found.`);
+    } else if (result.error === 'no_state_md') {
+      error(`Project "${slug}" has no STATE.md file.`);
+    } else if (result.error === 'not_completed') {
+      error(`Project "${slug}" is not completed.`);
+    } else {
+      error(`Failed to reactivate project "${slug}": ${result.error}`);
+    }
+  }
+
+  if (opts.set_current) {
+    writeConfigField(cwd, 'current_project', slug);
+  }
+
+  const regenResult = regenerateProjectsMd(cwd);
+  const remainingActive = regenResult.projects.filter(p => !p.status.toLowerCase().includes('completed'));
+
+  output({ reactivated: true, slug, set_as_current: !!opts.set_current, remaining_active: remainingActive.length }, raw);
+}
+
+/**
+ * CLI: Regenerate PROJECTS.md from disk.
+ *
+ * - Requires v2 install
+ * - Scans all project folders and re-derives PROJECTS.md
+ *
+ * @param {string} cwd - Working directory (product root)
+ * @param {boolean} raw - Raw output mode
+ */
+function cmdProjectsRegenerate(cwd, raw) {
+  if (!isV2Install(cwd)) error('v2 install required. Run /dgs:init-product first.');
+
+  const result = regenerateProjectsMd(cwd);
+  output({ regenerated: true, projects: result.projects, warnings: result.warnings }, raw);
+}
+
+// ─── Exports ────────────────────────────────────────────────────────────────
+
+module.exports = {
+  createProjectSubfolder,
+  readProjectState,
+  scanProjectReposTags,
+  regenerateProjectsMd,
+  completeProject,
+  reactivateProject,
+  parseProjectsMd,
+  checkSlugPrefixCollision,
+  cmdProjectsCreate,
+  cmdProjectsSwitch,
+  cmdProjectsList,
+  cmdProjectsComplete,
+  cmdProjectsReactivate,
+  cmdProjectsRegenerate,
+};