@opengsd/gsd-core 1.5.0-rc.2 → 1.5.0-rc.3

package/gsd-core/bin/lib/profile-output.cjs

@@ -653,7 +653,21 @@ function cmdWriteProfile(cwd, options, raw) {
     }
     let outputPath = options.output;
     if (!outputPath) {
-        outputPath = node_path_1.default.join(node_os_1.default.homedir(), '.claude', 'gsd-core', 'USER-PROFILE.md');
+        // #1114: resolve the ACTIVE runtime's config home so the profile is written
+        // where the runtime's own workflows look for it. Previously this hardcoded the
+        // Claude home, so a Codex run wrote the profile under the Claude config dir
+        // while Codex advisor-mode (installed under the Codex home) checked the Codex
+        // dir and never found it. Mirrors cmdGenerateDevPreferences' runtime resolution.
+        let effectiveRuntime = 'claude';
+        try {
+            const config = loadConfig(cwd);
+            effectiveRuntime = (0, runtime_name_policy_cjs_1.resolveRuntimeNameFromCandidates)(process.env['GSD_RUNTIME'], config['runtime'], 'claude') || 'claude';
+        }
+        catch {
+            effectiveRuntime = (0, runtime_name_policy_cjs_1.resolveRuntimeNameFromCandidates)(process.env['GSD_RUNTIME'], 'claude') || 'claude';
+        }
+        // path.join (not a string literal) keeps the cline-install leaked-path lint quiet.
+        outputPath = node_path_1.default.join((0, runtime_homes_cjs_1.getGlobalConfigDir)(effectiveRuntime), 'gsd-core', 'USER-PROFILE.md');
     }
     else if (!node_path_1.default.isAbsolute(outputPath)) {
         outputPath = node_path_1.default.join(cwd, outputPath);
@@ -911,8 +925,10 @@ function cmdGenerateClaudeProfile(cwd, options, raw) {
         targetPath = node_path_1.default.isAbsolute(options.output) ? options.output : node_path_1.default.join(cwd, options.output);
     }
     else {
-        // Read claude_md_path from config, default to ./CLAUDE.md
-        let configClaudeMdPath = './CLAUDE.md';
+        // Read claude_md_path from config; #1098 default is ./.claude/CLAUDE.md
+        // (kept consistent with cmdGenerateClaudeMd so the profile section and the
+        // managed sections land in the same file on a config-less project).
+        let configClaudeMdPath = './.claude/CLAUDE.md';
         try {
             const config = loadConfig(cwd);
             if (config['claude_md_path'])
@@ -986,7 +1002,12 @@ function cmdGenerateClaudeMd(cwd, options, raw) {
         }
     }
     let assemblyConfig = {};
-    let configClaudeMdPath = './CLAUDE.md';
+    // #1098: default the Claude-family instruction file to the project-scoped
+    // `.claude/CLAUDE.md` (a valid auto-loaded memory location) rather than a
+    // repo-root `CLAUDE.md`, so generated GSD content does not land next to — or
+    // pollute — a hand-crafted repo-root CLAUDE.md. An explicit `claude_md_path`
+    // config value or `--output` still wins.
+    let configClaudeMdPath = './.claude/CLAUDE.md';
     try {
         const config = loadConfig(cwd);
         if (config['claude_md_path'])
@@ -1037,6 +1058,26 @@ function cmdGenerateClaudeMd(cwd, options, raw) {
         (0, shell_command_projection_cjs_1.platformEnsureDir)(node_path_1.default.dirname(outputPath));
         (0, shell_command_projection_cjs_1.platformWriteSync)(outputPath, existingContent);
     }
+    else if (!/<!-- GSD:[a-z]+-start/.test(existingContent) && !options.force) {
+        // #1098: the target instruction file already exists and contains NO GSD
+        // section markers — it is a hand-crafted CLAUDE.md/AGENTS.md, not a
+        // GSD-managed one. Do NOT clobber it with generated project documentation
+        // (broad project detail belongs in PROJECT.md / REQUIREMENTS.md, which GSD
+        // already owns). Leave the file untouched and report a skip; `--force`
+        // overwrites intentionally.
+        output({
+            claude_md_path: outputPath,
+            action: 'skipped',
+            reason: 'existing instruction file has no GSD markers (hand-crafted); not overwriting. Pass --force to overwrite.',
+            sections_generated: [],
+            sections_fallback: [],
+            sections_skipped: MANAGED_SECTIONS,
+            sections_total: MANAGED_SECTIONS.length,
+            profile_status: 'skipped',
+            message: `Left existing ${node_path_1.default.basename(outputPath)} untouched (no GSD markers found). Broad project context lives in PROJECT.md / REQUIREMENTS.md; pass --force to overwrite this file with GSD-managed sections.`,
+        }, raw, undefined);
+        return;
+    }
     else {
         action = 'updated';
         let fileContent = existingContent;

package/gsd-core/bin/lib/profile-pipeline-command-router.cjs

@@ -0,0 +1,138 @@
+'use strict';
+/**
+ * Profile-pipeline command router — CLI dispatcher for gsd-tools profiling commands.
+ *
+ * ADR-857 phase 6 / ADR-959: profile-pipeline capability command cutover.
+ * Extracted from hardcoded case arms in gsd-tools.cjs (lines 1324-1410).
+ * Dispatch path: default → dispatchCapabilityCommand →
+ *   require(profile-pipeline-command-router.cjs) → route<X>.
+ *
+ * Router signature: { args, cwd, raw, error } — identical to existing routers.
+ * Test seams: _pipeline / _output inject mock modules; _core injects mock core.
+ *
+ * Async note: cmdExtractMessages and cmdProfileSample are async functions.
+ * dispatchCapabilityCommand (gsd-tools.cjs:366-371) explicitly errors if a
+ * router returns a Promise. Therefore these router functions call the async
+ * function WITHOUT await and WITHOUT returning the Promise. The async functions
+ * end with output() or process.exit() so the process terminates correctly once
+ * the event loop drains. Unhandled rejections are caught by the .catch() wrapper
+ * to surface errors via the error() callback.
+ */
+const { ERROR_REASON } = require('./io.cjs');
+
+// ─── Pipeline phase commands ───────────────────────────────────────────────────
+
+function routeScanSessions({ args, cwd, raw, error, _pipeline }) {
+  void cwd; void error;
+  const p = _pipeline ?? require('./profile-pipeline.cjs');
+  const pathIdx = args.indexOf('--path');
+  const sessionsPath = pathIdx !== -1 ? args[pathIdx + 1] : null;
+  const verboseFlag = args.includes('--verbose');
+  const jsonFlag = args.includes('--json');
+  // cmdScanSessions is synchronous — call directly.
+  p.cmdScanSessions(sessionsPath, { verbose: verboseFlag, json: jsonFlag }, raw);
+}
+
+function routeExtractMessages({ args, cwd, raw, error, _pipeline }) {
+  const p = _pipeline ?? require('./profile-pipeline.cjs');
+  const sessionIdx = args.indexOf('--session');
+  const sessionId = sessionIdx !== -1 ? args[sessionIdx + 1] : null;
+  const limitIdx = args.indexOf('--limit');
+  const limit = limitIdx !== -1 ? parseInt(args[limitIdx + 1], 10) : null;
+  const pathIdx = args.indexOf('--path');
+  const sessionsPath = pathIdx !== -1 ? args[pathIdx + 1] : null;
+  // args[0] = 'extract-messages' (family name), args[1] = project positional
+  const projectArg = args[1];
+  if (!projectArg || projectArg.startsWith('--')) {
+    error('Usage: gsd-tools extract-messages <project> [--session <id>] [--limit N] [--path <dir>]\nRun scan-sessions first to see available projects.', ERROR_REASON.USAGE);
+    return;
+  }
+  // cmdExtractMessages is async — do NOT return the Promise.
+  // The function ends with output() or process.exit(); the event loop will drain.
+  void cwd;
+  p.cmdExtractMessages(projectArg, { sessionId, limit }, raw, sessionsPath)
+    .catch(e => { error(e && e.message ? e.message : String(e)); });
+}
+
+function routeProfileSample({ args, cwd, raw, error, _pipeline }) {
+  void cwd; void error;
+  const p = _pipeline ?? require('./profile-pipeline.cjs');
+  const pathIdx = args.indexOf('--path');
+  const sessionsPath = pathIdx !== -1 ? args[pathIdx + 1] : null;
+  const limitIdx = args.indexOf('--limit');
+  const limit = limitIdx !== -1 ? parseInt(args[limitIdx + 1], 10) : 150;
+  const maxPerIdx = args.indexOf('--max-per-project');
+  const maxPerProject = maxPerIdx !== -1 ? parseInt(args[maxPerIdx + 1], 10) : null;
+  const maxCharsIdx = args.indexOf('--max-chars');
+  const maxChars = maxCharsIdx !== -1 ? parseInt(args[maxCharsIdx + 1], 10) : 500;
+  // cmdProfileSample is async — do NOT return the Promise.
+  p.cmdProfileSample(sessionsPath, { limit, maxPerProject, maxChars }, raw)
+    .catch(e => { error(e && e.message ? e.message : String(e)); });
+}
+
+// ─── Output phase commands ─────────────────────────────────────────────────────
+
+function routeWriteProfile({ args, cwd, raw, error, _output }) {
+  const o = _output ?? require('./profile-output.cjs');
+  const inputIdx = args.indexOf('--input');
+  const inputPath = inputIdx !== -1 ? args[inputIdx + 1] : null;
+  if (!inputPath) {
+    error('--input <analysis-json-path> is required', ERROR_REASON.USAGE);
+    return;
+  }
+  const outputIdx = args.indexOf('--output');
+  const outputPath = outputIdx !== -1 ? args[outputIdx + 1] : null;
+  o.cmdWriteProfile(cwd, { input: inputPath, output: outputPath }, raw);
+}
+
+function routeProfileQuestionnaire({ args, cwd, raw, error, _output }) {
+  void cwd; void error;
+  const o = _output ?? require('./profile-output.cjs');
+  const answersIdx = args.indexOf('--answers');
+  const answers = answersIdx !== -1 ? args[answersIdx + 1] : null;
+  o.cmdProfileQuestionnaire({ answers }, raw);
+}
+
+function routeGenerateDevPreferences({ args, cwd, raw, error, _output }) {
+  void error;
+  const o = _output ?? require('./profile-output.cjs');
+  const analysisIdx = args.indexOf('--analysis');
+  const analysisPath = analysisIdx !== -1 ? args[analysisIdx + 1] : null;
+  const outputIdx = args.indexOf('--output');
+  const outputPath = outputIdx !== -1 ? args[outputIdx + 1] : null;
+  const stackIdx = args.indexOf('--stack');
+  const stack = stackIdx !== -1 ? args[stackIdx + 1] : null;
+  o.cmdGenerateDevPreferences(cwd, { analysis: analysisPath, output: outputPath, stack }, raw);
+}
+
+function routeGenerateClaudeProfile({ args, cwd, raw, error, _output }) {
+  void error;
+  const o = _output ?? require('./profile-output.cjs');
+  const analysisIdx = args.indexOf('--analysis');
+  const analysisPath = analysisIdx !== -1 ? args[analysisIdx + 1] : null;
+  const outputIdx = args.indexOf('--output');
+  const outputPath = outputIdx !== -1 ? args[outputIdx + 1] : null;
+  const globalFlag = args.includes('--global');
+  o.cmdGenerateClaudeProfile(cwd, { analysis: analysisPath, output: outputPath, global: globalFlag }, raw);
+}
+
+function routeGenerateClaudeMd({ args, cwd, raw, error, _output }) {
+  void error;
+  const o = _output ?? require('./profile-output.cjs');
+  const outputIdx = args.indexOf('--output');
+  const outputPath = outputIdx !== -1 ? args[outputIdx + 1] : null;
+  const autoFlag = args.includes('--auto');
+  const forceFlag = args.includes('--force');
+  o.cmdGenerateClaudeMd(cwd, { output: outputPath, auto: autoFlag, force: forceFlag }, raw);
+}
+
+module.exports = {
+  routeScanSessions,
+  routeExtractMessages,
+  routeProfileSample,
+  routeWriteProfile,
+  routeProfileQuestionnaire,
+  routeGenerateDevPreferences,
+  routeGenerateClaudeProfile,
+  routeGenerateClaudeMd,
+};

package/gsd-core/bin/lib/roadmap.cjs

@@ -11,6 +11,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
+const clock_cjs_1 = require("./clock.cjs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const core = require("./core.cjs");
 const { escapeRegex, normalizePhaseName, phaseMarkdownRegexSource, phaseMarkdownRegexSourceExact, output, error, findPhaseInternal, phaseTokenMatches } = core;
@@ -386,7 +387,7 @@ function cmdRoadmapUpdatePlanProgress(cwd, phaseNum, raw) {
     }
     const isComplete = summaryCount >= planCount;
     const status = isComplete ? 'Complete' : summaryCount > 0 ? 'In Progress' : 'Planned';
-    const today = new Date().toISOString().split('T')[0];
+    const today = clock_cjs_1.realClock.today();
     if (!node_fs_1.default.existsSync(roadmapPath)) {
         output({ updated: false, reason: 'ROADMAP.md not found', plan_count: planCount, summary_count: summaryCount }, raw, 'no roadmap');
         return;
@@ -397,25 +398,37 @@ function cmdRoadmapUpdatePlanProgress(cwd, phaseNum, raw) {
         const phasePattern = phaseMarkdownRegexSource(phaseNum);
         // Progress table row: update Plans/Status/Date columns (handles 4 or 5 column tables)
         const tableRowPattern = new RegExp(`^(\\|\\s*${phasePattern}\\.?\\s[^|]*(?:\\|[^\\n]*))$`, 'im');
-        const dateField = isComplete ? ` ${today} ` : '  ';
         roadmapContent = roadmapContent.replace(tableRowPattern, (fullRow) => {
             const cells = fullRow.split('|').slice(1, -1); // drop leading/trailing empty from split
+            const dateShape = /^\d{4}-\d{2}-\d{2}$/;
             if (cells.length === 5) {
                 // 5-col: Phase | Milestone | Plans | Status | Completed
                 cells[2] = ` ${summaryCount}/${planCount} `;
                 cells[3] = ` ${status.padEnd(11)}`;
-                cells[4] = dateField;
+                // Preserve only a valid ISO date (#1161: idempotent; self-heal garbage)
+                const existingDate5 = cells[4].trim();
+                cells[4] = isComplete
+                    ? (dateShape.test(existingDate5) ? cells[4] : ` ${today} `)
+                    : '  ';
             }
             else if (cells.length === 4) {
                 // 4-col: Phase | Plans | Status | Completed
                 cells[1] = ` ${summaryCount}/${planCount} `;
                 cells[2] = ` ${status.padEnd(11)}`;
-                cells[3] = dateField;
+                // Preserve only a valid ISO date (#1161: idempotent; self-heal garbage)
+                const existingDate4 = cells[3].trim();
+                cells[3] = isComplete
+                    ? (dateShape.test(existingDate4) ? cells[3] : ` ${today} `)
+                    : '  ';
             }
             return '|' + cells.join('|') + '|';
         });
-        // Update plan count in phase detail section
-        const planCountPattern = new RegExp(`(#{2,4}\\s*Phase\\s+${phasePattern}(?=[:\\s])[\\s\\S]*?\\*\\*Plans:\\*\\*\\s*)[^\\n]+`, 'i');
+        // Update plan count in phase detail section.
+        // Three recognised forms (all tolerated; canonical template uses the first):
+        //   `**Plans**: N plans`  — bold word + outer colon (gsd-core/templates/roadmap.md)
+        //   `**Plans:** N plans`  — bold "Plans:" (colon inside bold)
+        //   `Plans: N plans`      — plain text header
+        const planCountPattern = new RegExp(`(#{2,4}\\s*Phase\\s+${phasePattern}(?=[:\\s])[\\s\\S]*?(?:\\*\\*Plans\\*\\*:|\\*\\*Plans:\\*\\*|(?:^|\\n)Plans:)\\s*)[^\\n]+`, 'i');
         const planCountText = isComplete
             ? `${summaryCount}/${planCount} plans complete`
             : `${summaryCount}/${planCount} plans executed`;
@@ -434,6 +447,80 @@ function cmdRoadmapUpdatePlanProgress(cwd, phaseNum, raw) {
             const planCheckboxPattern = new RegExp(`(-\\s*\\[) (\\]\\s*(?:\\*\\*)?${planEscaped}(?:\\*\\*)?)`, 'i');
             roadmapContent = roadmapContent.replace(planCheckboxPattern, '$1x$2');
         }
+        // Compute the active (post-</details>) region offset ONCE.  Both the
+        // missing-plan DETECTION and the row INSERTION must use the same active
+        // region string so that a plan row that exists only in an archived <details>
+        // block is not counted as "already present" in the active milestone section.
+        // (Finding 1 code-review: detection was previously running against the full
+        //  roadmapContent, causing archived rows to suppress active-section inserts.)
+        const lastDetailsClose = roadmapContent.lastIndexOf('</details>');
+        const activeRegion = lastDetailsClose === -1
+            ? roadmapContent
+            : roadmapContent.slice(lastDetailsClose + '</details>'.length);
+        // Compute which plan files are MISSING a checkbox row in the ACTIVE region.
+        // This handles three cases:
+        //   (a) Fresh template — no rows at all: all plans are missing.
+        //   (b) Partial gap — some rows exist, others don't: only the absent ones.
+        //   (c) All rows present — nothing to insert (idempotent).
+        //
+        // Detection is scoped to the active region so a plan that appears in an
+        // archived <details> block is still correctly detected as missing from the
+        // active milestone section.
+        const missingPlans = phaseInfo.plans.filter((planFile) => {
+            const planEscaped = escapeRegex(planFile);
+            return !new RegExp(`-\\s*\\[[x ]\\]\\s*(?:\\*\\*)?${planEscaped}`, 'i').test(activeRegion);
+        });
+        if (missingPlans.length > 0) {
+            // Insert missing plan checklist rows (#1163).  We prefer to anchor to the
+            // bare `Plans:` checklist header (canonical template form) and fall back to
+            // the bold `**Plans**:`/`**Plans:**` summary line only when no bare header
+            // is present.  Using two separate patterns avoids the lazy-quantifier trap
+            // where a single alternation would stop at the first matching alternative
+            // (the bold summary) before reaching the checklist header.
+            //
+            // Canonical template (gsd-core/templates/roadmap.md) uses BOTH lines:
+            //   **Plans**: N plans   ← summary (colon outside bold)
+            //   Plans:               ← checklist header (PREFERRED insertion anchor)
+            // Rows must land after `Plans:`, not between the summary and the header.
+            //
+            // Pattern A: anchor to bare `Plans:` header (preferred).
+            // Pattern B: fallback to bold summary when no bare header exists.
+            const insertRowsPatternA = new RegExp(`(#{2,4}\\s*Phase\\s+${phasePattern}(?=[:\\s])[\\s\\S]*?(?:^|\\n)(?:Plans:)[^\\n]*)`, 'i');
+            const insertRowsPatternB = new RegExp(`(#{2,4}\\s*Phase\\s+${phasePattern}(?=[:\\s])[\\s\\S]*?(?:\\*\\*Plans\\*\\*:|\\*\\*Plans:\\*\\*)[^\\n]*)`, 'i');
+            const sortedMissing = [...missingPlans].sort();
+            const newRows = sortedMissing.map(p => `- [ ] ${p}`).join('\n');
+            const inserter = (match) => `${match}\n${newRows}`;
+            // Scope insertion to the active (post-</details>) milestone region to
+            // prevent duplicate phase headings in archived sections from receiving rows.
+            // replaceInCurrentMilestone only accepts a string replacement, so we
+            // perform the scoped replace manually here (same strategy as that helper).
+            // Note: lastDetailsClose was computed above (shared with detection).
+            const scopedReplace = (src, pat) => src.replace(pat, inserter);
+            let withRows;
+            if (lastDetailsClose === -1) {
+                // activeRegion === roadmapContent when there are no </details> blocks.
+                const regionA = scopedReplace(activeRegion, insertRowsPatternA);
+                withRows = regionA !== activeRegion ? regionA : scopedReplace(activeRegion, insertRowsPatternB);
+            }
+            else {
+                const beforeDetails = roadmapContent.slice(0, lastDetailsClose + '</details>'.length);
+                const regionA = scopedReplace(activeRegion, insertRowsPatternA);
+                const afterWithRows = regionA !== activeRegion ? regionA : scopedReplace(activeRegion, insertRowsPatternB);
+                withRows = beforeDetails + afterWithRows;
+            }
+            if (withRows !== roadmapContent) {
+                roadmapContent = withRows;
+                // Mark any newly-inserted rows that already have summaries as complete
+                for (const summaryFile of phaseInfo.summaries) {
+                    const planId = summaryFile.replace('-SUMMARY.md', '').replace('SUMMARY.md', '');
+                    if (!planId)
+                        continue;
+                    const planEscaped = escapeRegex(planId);
+                    const planCheckboxPattern = new RegExp(`(-\\s*\\[) (\\]\\s*(?:\\*\\*)?${planEscaped}(?:\\*\\*)?)`, 'i');
+                    roadmapContent = roadmapContent.replace(planCheckboxPattern, '$1x$2');
+                }
+            }
+        }
         (0, shell_command_projection_cjs_1.platformWriteSync)(roadmapPath, roadmapContent);
     });
     output({
@@ -620,7 +707,10 @@ function cmdRoadmapAnnotateDependencies(cwd, phaseNum, raw) {
             }
         }
         const newListBlock = annotatedLines.join('\n') + '\n';
-        const newPhaseSection = phaseSection.replace(plansBlockMatch[0], plansHeader + newListBlock);
+        // #1103: when `(?:^|\n)` consumed a leading `\n` (mid-string match), re-emit it
+        // so the line preceding the Plans: header is not fused onto it.
+        const leadingNewline = plansBlockMatch[0].startsWith('\n') ? '\n' : '';
+        const newPhaseSection = phaseSection.replace(plansBlockMatch[0], leadingNewline + plansHeader + newListBlock);
         const nextContent = content.slice(0, phaseStart) + newPhaseSection + content.slice(phaseEnd);
         if (nextContent === content)
             return;