@ktpartners/dgs-platform 2.8.0 → 3.0.4

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

@@ -4,32 +4,29 @@
 
 const fs = require('fs');
 const path = require('path');
-const { escapeRegex, getMilestonePhaseFilter, output, error } = require('./core.cjs');
+const { escapeRegex, getMilestonePhaseFilter, getProjectRoot, output, error } = require('./core.cjs');
 const { extractFrontmatter } = require('./frontmatter.cjs');
 const { getPlanningRoot } = require('./paths.cjs');
 const { writeStateMd } = require('./state.cjs');
 
-function cmdRequirementsMarkComplete(cwd, reqIdsRaw, raw) {
-  if (!reqIdsRaw || reqIdsRaw.length === 0) {
-    error('requirement IDs required. Usage: requirements mark-complete REQ-01,REQ-02 or REQ-01 REQ-02');
-  }
-
-  // Accept comma-separated, space-separated, or bracket-wrapped: [REQ-01, REQ-02]
-  const reqIds = reqIdsRaw
-    .join(' ')
-    .replace(/[\[\]]/g, '')
-    .split(/[,\s]+/)
-    .map(r => r.trim())
-    .filter(Boolean);
-
-  if (reqIds.length === 0) {
+/**
+ * Internal helper: marks requirement IDs complete in REQUIREMENTS.md.
+ * Accepts an already-parsed array of IDs. Returns { result, reqPath, rawValue }
+ * WITHOUT calling output()/exit.
+ */
+function requirementsMarkCompleteInternal(cwd, reqIds) {
+  if (!Array.isArray(reqIds) || reqIds.length === 0) {
     error('no valid requirement IDs found');
   }
 
-  const reqPath = path.join(getPlanningRoot(cwd), 'REQUIREMENTS.md');
+  const projectRootRel = getProjectRoot(cwd);
+  const reqPath = path.join(getPlanningRoot(cwd), projectRootRel, 'REQUIREMENTS.md');
   if (!fs.existsSync(reqPath)) {
-    output({ updated: false, reason: 'REQUIREMENTS.md not found', ids: reqIds }, raw, 'no requirements file');
-    return;
+    return {
+      result: { updated: false, reason: 'REQUIREMENTS.md not found', ids: reqIds },
+      reqPath,
+      rawValue: 'no requirements file',
+    };
   }
 
   let reqContent = fs.readFileSync(reqPath, 'utf-8');
@@ -69,12 +66,37 @@ function cmdRequirementsMarkComplete(cwd, reqIdsRaw, raw) {
     fs.writeFileSync(reqPath, reqContent, 'utf-8');
   }
 
-  output({
-    updated: updated.length > 0,
-    marked_complete: updated,
-    not_found: notFound,
-    total: reqIds.length,
-  }, raw, `${updated.length}/${reqIds.length} requirements marked complete`);
+  return {
+    result: {
+      updated: updated.length > 0,
+      marked_complete: updated,
+      not_found: notFound,
+      total: reqIds.length,
+    },
+    reqPath,
+    rawValue: `${updated.length}/${reqIds.length} requirements marked complete`,
+  };
+}
+
+function cmdRequirementsMarkComplete(cwd, reqIdsRaw, raw) {
+  if (!reqIdsRaw || reqIdsRaw.length === 0) {
+    error('requirement IDs required. Usage: requirements mark-complete REQ-01,REQ-02 or REQ-01 REQ-02');
+  }
+
+  // Accept comma-separated, space-separated, or bracket-wrapped: [REQ-01, REQ-02]
+  const reqIds = reqIdsRaw
+    .join(' ')
+    .replace(/[\[\]]/g, '')
+    .split(/[,\s]+/)
+    .map(r => r.trim())
+    .filter(Boolean);
+
+  if (reqIds.length === 0) {
+    error('no valid requirement IDs found');
+  }
+
+  const { result, rawValue } = requirementsMarkCompleteInternal(cwd, reqIds);
+  output(result, raw, rawValue);
 }
 
 function cmdMilestoneComplete(cwd, version, options, raw) {
@@ -83,12 +105,14 @@ function cmdMilestoneComplete(cwd, version, options, raw) {
   }
 
   const planRoot = getPlanningRoot(cwd);
-  const roadmapPath = path.join(planRoot, 'ROADMAP.md');
-  const reqPath = path.join(planRoot, 'REQUIREMENTS.md');
-  const statePath = path.join(planRoot, 'STATE.md');
+  const projectRootRel = getProjectRoot(cwd);
+  const projectRoot = path.join(planRoot, projectRootRel);
+  const roadmapPath = path.join(projectRoot, 'ROADMAP.md');
+  const reqPath = path.join(projectRoot, 'REQUIREMENTS.md');
+  const statePath = path.join(projectRoot, 'STATE.md');
   const milestonesPath = path.join(planRoot, 'MILESTONES.md');
   const archiveDir = path.join(planRoot, 'milestones');
-  const phasesDir = path.join(planRoot, 'phases');
+  const phasesDir = path.join(projectRoot, 'phases');
   const today = new Date().toISOString().split('T')[0];
   const milestoneName = options.name || version;
 
@@ -149,7 +173,7 @@ function cmdMilestoneComplete(cwd, version, options, raw) {
   }
 
   // Archive audit file if exists
-  const auditFile = path.join(planRoot, `${version}-MILESTONE-AUDIT.md`);
+  const auditFile = path.join(projectRoot, `${version}-MILESTONE-AUDIT.md`);
   if (fs.existsSync(auditFile)) {
     fs.renameSync(auditFile, path.join(archiveDir, `${version}-MILESTONE-AUDIT.md`));
   }
@@ -239,5 +263,6 @@ function cmdMilestoneComplete(cwd, version, options, raw) {
 
 module.exports = {
   cmdRequirementsMarkComplete,
+  requirementsMarkCompleteInternal,
   cmdMilestoneComplete,
 };

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

@@ -4,7 +4,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { escapeRegex, normalizePhaseName, comparePhaseNum, findPhaseInternal, getArchivedPhaseDirs, generateSlugInternal, getMilestonePhaseFilter, toPosixPath, output, error, getProjectRoot } = require('./core.cjs');
+const { escapeRegex, normalizePhaseName, comparePhaseNum, findPhaseInternal, getArchivedPhaseDirs, generateSlugInternal, getMilestonePhaseFilter, toPosixPath, output, error, getProjectRoot, loadConfig, execGit } = require('./core.cjs');
 const { extractFrontmatter } = require('./frontmatter.cjs');
 const { writeStateMd } = require('./state.cjs');
 
@@ -381,6 +381,17 @@ function cmdPhaseAdd(cwd, description, raw) {
     updatedContent = content + phaseEntry;
   }
 
+  // Update milestone summary range (e.g., "Phases 124-128" -> "Phases 124-129")
+  const rangePattern = /Phases\s+(\d+)-(\d+)\s*\(in progress\)/;
+  const rangeMatch = updatedContent.match(rangePattern);
+  if (rangeMatch) {
+    const rangeEnd = parseInt(rangeMatch[2], 10);
+    if (newPhaseNum > rangeEnd) {
+      updatedContent = updatedContent.replace(rangePattern,
+        `Phases ${rangeMatch[1]}-${newPhaseNum} (in progress)`);
+    }
+  }
+
   fs.writeFileSync(roadmapPath, updatedContent, 'utf-8');
 
   const relPhasesDir = path.relative(cwd, phasesDir);
@@ -732,7 +743,16 @@ function cmdPhaseRemove(cwd, targetPhase, options, raw) {
   output(result, raw);
 }
 
-function cmdPhaseComplete(cwd, phaseNum, raw) {
+/**
+ * Internal helper: executes the phase-complete logic (ROADMAP/STATE/REQUIREMENTS
+ * updates + next-phase lookup) WITHOUT emitting output/exit.
+ *
+ * Returns { result, roadmapPath, statePath, requirementsPath, phaseDir }.
+ * The `result` object matches what cmdPhaseComplete emits. Paths are absolute.
+ * `requirementsPath` is returned even when the file doesn't exist (caller decides).
+ * `phaseDir` is the absolute path to the phase directory on disk.
+ */
+function phaseCompleteInternal(cwd, phaseNum) {
   if (!phaseNum) {
     error('phase number required for phase complete');
   }
@@ -740,6 +760,7 @@ function cmdPhaseComplete(cwd, phaseNum, raw) {
   const projRoot = resolveProjectRoot(cwd);
   const roadmapPath = path.join(cwd, projRoot, 'ROADMAP.md');
   const statePath = path.join(cwd, projRoot, 'STATE.md');
+  const requirementsPath = path.join(cwd, projRoot, 'REQUIREMENTS.md');
   const phasesDir = resolvePhasesDir(cwd);
   const normalized = normalizePhaseName(phaseNum);
   const today = new Date().toISOString().split('T')[0];
@@ -750,6 +771,11 @@ function cmdPhaseComplete(cwd, phaseNum, raw) {
     error(`Phase ${phaseNum} not found`);
   }
 
+  // Absolute phase directory (phaseInfo.directory is relative to cwd)
+  const phaseDir = phaseInfo.directory
+    ? path.join(cwd, phaseInfo.directory)
+    : null;
+
   const planCount = phaseInfo.plans.length;
   const summaryCount = phaseInfo.summaries.length;
 
@@ -896,6 +922,104 @@ function cmdPhaseComplete(cwd, phaseNum, raw) {
     state_updated: fs.existsSync(statePath),
   };
 
+  return { result, roadmapPath, statePath, requirementsPath, phaseDir };
+}
+
+/**
+ * CLI: `phase complete <phase>`. Thin wrapper over phaseCompleteInternal that
+ * emits the result and exits. External behavior unchanged from prior versions.
+ */
+function cmdPhaseComplete(cwd, phaseNum, raw) {
+  const { result } = phaseCompleteInternal(cwd, phaseNum);
+  output(result, raw);
+}
+
+/**
+ * CLI: `phase finalize <phase> [--push]`.
+ *
+ * Runs phaseCompleteInternal (ROADMAP/STATE/REQUIREMENTS updates) AND commits
+ * the modified tracking files + any `*-VERIFICATION.md` files in the phase dir
+ * in a single atomic call. Respects config.commit_docs (skip commit if false;
+ * still writes files). Handles --push for sync_push=auto|prompt modes.
+ *
+ * Does NOT call cmdCommit (which exits). Uses execGit directly.
+ */
+function cmdPhaseFinalize(cwd, phaseNum, options, raw) {
+  if (!phaseNum) {
+    error('phase number required for phase finalize');
+  }
+
+  const { result, roadmapPath, statePath, requirementsPath, phaseDir } =
+    phaseCompleteInternal(cwd, phaseNum);
+
+  // Gather tracking files that exist on disk (skip missing files gracefully)
+  const filesToStage = [];
+  for (const p of [roadmapPath, statePath, requirementsPath]) {
+    if (p && fs.existsSync(p)) {
+      filesToStage.push(path.relative(cwd, p));
+    }
+  }
+  // Include every *-VERIFICATION.md in the phase directory
+  if (phaseDir && fs.existsSync(phaseDir)) {
+    try {
+      const entries = fs.readdirSync(phaseDir).filter(f => /-VERIFICATION\.md$/i.test(f));
+      for (const f of entries) {
+        filesToStage.push(path.relative(cwd, path.join(phaseDir, f)));
+      }
+    } catch { /* ignore */ }
+  }
+
+  // Honor config.commit_docs — file writes already happened, just skip commit.
+  const config = loadConfig(cwd);
+  if (!config.commit_docs) {
+    result.committed = false;
+    result.commit_reason = 'skipped_commit_docs_false';
+    result.files_committed = [];
+    output(result, raw);
+    return;
+  }
+
+  // Stage + commit atomically (cmdCommit calls output/exit — inline instead).
+  for (const f of filesToStage) {
+    execGit(cwd, ['add', f]);
+  }
+  const message = `docs(phase-${phaseNum}): complete phase execution`;
+  const commitResult = execGit(cwd, ['commit', '-m', message]);
+  if (commitResult.exitCode !== 0) {
+    const nothing =
+      commitResult.stdout.includes('nothing to commit') ||
+      commitResult.stderr.includes('nothing to commit');
+    result.committed = false;
+    result.commit_reason = nothing ? 'nothing_to_commit' : 'commit_failed';
+    if (!nothing) result.commit_error = commitResult.stderr;
+    result.files_committed = [];
+    output(result, raw);
+    return;
+  }
+  const hashResult = execGit(cwd, ['rev-parse', '--short', 'HEAD']);
+  result.committed = true;
+  result.hash = hashResult.exitCode === 0 ? hashResult.stdout : null;
+  result.commit_reason = 'committed';
+  result.files_committed = filesToStage;
+
+  // Optional push (same semantics as cmdCommit)
+  if (options && options.push) {
+    const syncPush = config.sync_push || 'off';
+    if (syncPush === 'auto') {
+      try {
+        const { pushAll } = require('./sync.cjs');
+        const pushRes = pushAll(cwd, { force: true });
+        result.pushed = pushRes.ok;
+        result.push_result = pushRes;
+      } catch (err) {
+        result.pushed = false;
+        result.push_result = { ok: false, error: err.message };
+      }
+    } else if (syncPush === 'prompt') {
+      result.needs_push = true;
+    }
+  }
+
   output(result, raw);
 }
 
@@ -908,4 +1032,6 @@ module.exports = {
   cmdPhaseInsert,
   cmdPhaseRemove,
   cmdPhaseComplete,
+  cmdPhaseFinalize,
+  phaseCompleteInternal,
 };