@ktpartners/dgs-platform 2.7.5 → 2.9.0

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

@@ -11,17 +11,11 @@ const path = require('path');
 const { safeReadFile, execGit, isV2Install, output, error } = require('./core.cjs');
 const { writeConfigField } = require('./config.cjs');
 const { getPlanningRoot, resetPaths } = require('./paths.cjs');
-// Lazy-loaded to avoid circular dependency (migration.cjs requires writeReposMd from this file)
-let _migration;
-function migration() {
-  if (!_migration) _migration = require('./migration.cjs');
-  return _migration;
-}
 
 // ─── REPOS.md Parse / Write ──────────────────────────────────────────────────
 
 /**
- * Parse .planning/REPOS.md into structured data.
+ * Parse REPOS.md into structured data.
  *
  * Returns null if the file doesn't exist or doesn't start with '# Repos'.
  * Returns { repos: [] } if the header exists but the table has no data rows.
@@ -76,7 +70,7 @@ function parseReposMd(cwd) {
 }
 
 /**
- * Write repos array to .planning/REPOS.md with standard format.
+ * Write repos array to REPOS.md with standard format.
  *
  * Creates the '# Repos' header (v2 marker), explanatory text, and
  * a properly formatted markdown table.
@@ -268,7 +262,6 @@ function extractRepoDescription(repoPath) {
  *
  * Scans for subdirectories containing .git/, excluding:
  * - node_modules
- * - .planning
  * - Dot-directories (starting with '.')
  * - Non-directories (files)
  *
@@ -513,7 +506,7 @@ function hasPathConflict(newPath, existingRepos) {
 // ─── PROJECTS.md Scaffold ────────────────────────────────────────────────────
 
 /**
- * Write .planning/PROJECTS.md with standard scaffold format.
+ * Write PROJECTS.MD with standard scaffold format.
  *
  * Creates the '# Projects' header (v2 marker), Active and Completed
  * sections with table headers.
@@ -689,124 +682,81 @@ function validateReposConsistency(planContent, repos) {
 // ─── Layout Detection ─────────────────────────────────────────────────────────
 
 /**
- * Detect the suggested layout mode for a repo based on its contents.
+ * Detect whether a repo has existing root-layout planning or is fresh.
  *
  * Heuristic (checked in order):
- * 1. .planning/ with config files -> dotplanning (existing setup)
- * 2. dgs.config.json at root with planningRoot:'.' -> root (already root setup)
- * 3. Repo is "empty-ish" (no source code indicators) AND no .planning/ -> root
- * 4. Planning artifacts at root (PROJECT.md, ROADMAP.md) without .planning/ -> root
- * 5. Default -> dotplanning (safer default)
+ * 1. config.local.json at root -> root (already configured)
+ * 2. Repo is empty-ish (no source code indicators at depth 1) -> root
+ * 3. Planning artifacts at root (PROJECT.md, ROADMAP.md) -> root
+ * 4. Default -> fresh (no planning setup detected)
  *
  * @param {string} cwd - Working directory (repo root)
  * @param {boolean} raw - Raw output mode
  */
 function cmdDetectLayout(cwd, raw) {
   const signals = [];
-  // Pre-init detection: must check .planning/ directly (not via getPlanningRoot)
-  const DOT_PLANNING_DIR = '.planning';
-  const dotPlanning = path.join(cwd, DOT_PLANNING_DIR);
-
-  // Signal 1: .planning/ directory with config files
-  if (
-    fs.existsSync(path.join(dotPlanning, 'config.json')) ||
-    fs.existsSync(path.join(dotPlanning, 'config.local.json')) ||
-    fs.existsSync(path.join(dotPlanning, 'dgs.config.json'))
-  ) {
-    signals.push('existing .planning/ directory with config files');
-    output({ suggested: 'dotplanning', signals }, raw);
-    return;
-  }
 
-  // Signal 2: config.local.json at root with planningRoot: '.'
+  // Signal 1: config.local.json at root
   const rootLocalConfigPath = path.join(cwd, 'config.local.json');
   if (fs.existsSync(rootLocalConfigPath)) {
-    try {
-      const config = JSON.parse(fs.readFileSync(rootLocalConfigPath, 'utf-8'));
-      if (config.planningRoot === '.') {
-        signals.push('config.local.json at root with planningRoot: "."');
-        output({ suggested: 'root', signals }, raw);
-        return;
-      }
-    } catch { /* malformed config -- continue detection */ }
+    signals.push('config.local.json at root');
+    output({ suggested: 'root', signals }, raw);
+    return;
   }
 
-  // Signal 2b: Legacy dgs.config.json at root with planningRoot: '.'
-  const rootConfigPath = path.join(cwd, 'dgs.config.json');
-  if (fs.existsSync(rootConfigPath)) {
-    try {
-      const config = JSON.parse(fs.readFileSync(rootConfigPath, 'utf-8'));
-      if (config.planningRoot === '.') {
-        signals.push('dgs.config.json at root with planningRoot: "."');
-        output({ suggested: 'root', signals }, raw);
-        return;
+  // Signal 2: Empty-ish repo (no source code indicators at depth 1)
+  let hasSourceIndicators = false;
+  try {
+    const entries = fs.readdirSync(cwd, { withFileTypes: true });
+    const SOURCE_EXTENSIONS = ['.ts', '.js', '.py', '.go', '.rs', '.java'];
+
+    for (const entry of entries) {
+      const name = entry.name;
+      // Skip hidden files/dirs
+      if (name.startsWith('.')) continue;
+
+      // Check for source code directories
+      if (entry.isDirectory() && (name === 'src' || name === 'lib')) {
+        hasSourceIndicators = true;
+        break;
       }
-    } catch { /* malformed config -- continue detection */ }
-  }
-
-  // Signal 3: Empty-ish repo (no source code indicators at depth 1)
-  const hasDotPlanning = fs.existsSync(dotPlanning);
-  if (!hasDotPlanning) {
-    let hasSourceIndicators = false;
-    try {
-      const entries = fs.readdirSync(cwd, { withFileTypes: true });
-      const SOURCE_EXTENSIONS = ['.ts', '.js', '.py', '.go', '.rs', '.java'];
 
-      for (const entry of entries) {
-        const name = entry.name;
-        // Skip hidden files/dirs
-        if (name.startsWith('.')) continue;
-
-        // Check for source code directories
-        if (entry.isDirectory() && (name === 'src' || name === 'lib')) {
-          hasSourceIndicators = true;
-          break;
-        }
+      // Check for package.json
+      if (name === 'package.json') {
+        hasSourceIndicators = true;
+        break;
+      }
 
-        // Check for package.json
-        if (name === 'package.json') {
+      // Check for source code files at depth 1
+      if (entry.isFile()) {
+        const ext = path.extname(name);
+        if (SOURCE_EXTENSIONS.includes(ext)) {
           hasSourceIndicators = true;
           break;
         }
-
-        // Check for source code files at depth 1
-        if (entry.isFile()) {
-          const ext = path.extname(name);
-          if (SOURCE_EXTENSIONS.includes(ext)) {
-            hasSourceIndicators = true;
-            break;
-          }
-        }
       }
-    } catch { /* can't read dir — treat as not empty-ish */ hasSourceIndicators = true; }
-
-    if (!hasSourceIndicators) {
-      signals.push('repo is empty-ish (no source code indicators at depth 1)');
-      output({ suggested: 'root', signals }, raw);
-      return;
     }
-  }
+  } catch { /* can't read dir -- treat as not empty-ish */ hasSourceIndicators = true; }
 
-  // Signal 4: Planning artifacts at root without .planning/
-  if (!hasDotPlanning) {
-    const hasPlanningArtifacts =
-      fs.existsSync(path.join(cwd, 'PROJECT.md')) ||
-      fs.existsSync(path.join(cwd, 'ROADMAP.md'));
-    if (hasPlanningArtifacts) {
-      signals.push('planning artifacts (PROJECT.md or ROADMAP.md) at root without .planning/');
-      output({ suggested: 'root', signals }, raw);
-      return;
-    }
+  if (!hasSourceIndicators) {
+    signals.push('repo is empty-ish (no source code indicators at depth 1)');
+    output({ suggested: 'root', signals }, raw);
+    return;
   }
 
-  // Signal 5: .planning/ directory exists (even without config files)
-  if (hasDotPlanning) {
-    signals.push('existing .planning/ directory');
+  // Signal 3: Planning artifacts at root
+  const hasPlanningArtifacts =
+    fs.existsSync(path.join(cwd, 'PROJECT.md')) ||
+    fs.existsSync(path.join(cwd, 'ROADMAP.md'));
+  if (hasPlanningArtifacts) {
+    signals.push('planning artifacts (PROJECT.md or ROADMAP.md) at root');
+    output({ suggested: 'root', signals }, raw);
+    return;
   }
 
-  // Default: dotplanning (safer default)
-  signals.push('default (no root-mode signals detected)');
-  output({ suggested: 'dotplanning', signals }, raw);
+  // Default: fresh (no planning setup detected)
+  signals.push('default (no planning setup detected)');
+  output({ suggested: 'fresh', signals }, raw);
 }
 
 // ─── Root-Layout .gitignore ───────────────────────────────────────────────────
@@ -1126,101 +1076,40 @@ function cmdReposResolve(cwd, filePath, raw) {
 }
 
 /**
- * Initialize a product folder structure (v2 mode).
- * Creates REPOS.md, PROJECTS.md, syncs .gitignore, updates config.
+ * Initialize a product folder structure (v2 mode, root layout).
+ * Creates REPOS.md, PROJECTS.md, generates .gitignore, updates config.
  *
- * Supports layout option:
- * - layout='root': Config-first pattern — writes dgs.config.json at repo root
- *   with planningRoot:'.', then creates all artifacts at repo root (no .planning/).
- * - layout=null (default): Standard .planning/ layout (unchanged).
+ * All initialization uses root layout -- config.local.json at repo root,
+ * planning artifacts at repo root (no subdirectory).
  *
  * @param {string} cwd - Working directory
  * @param {Object} options - { productName?: string, layout?: string }
  * @param {boolean} raw - Raw output mode
  */
 function cmdReposInitProduct(cwd, options, raw) {
-  const isRootMode = options.layout === 'root';
-
-  // ── Root-mode: Config-first pattern ───────────────────────────────────────
-  if (isRootMode) {
-    // Write config.local.json FIRST so getPlanningRoot returns repo root
-    const rootLocalConfigPath = path.join(cwd, 'config.local.json');
-    fs.writeFileSync(rootLocalConfigPath, JSON.stringify({ planningRoot: '.' }, null, 2));
-    // Write empty shared config.json at root
-    const rootSharedConfigPath = path.join(cwd, 'config.json');
-    if (!fs.existsSync(rootSharedConfigPath)) {
-      fs.writeFileSync(rootSharedConfigPath, JSON.stringify({}, null, 2));
-    }
-    resetPaths(); // Clear stale cache so getPlanningRoot resolves to cwd
-
-    // Check if already initialized (idempotency)
-    if (isV2Install(cwd)) {
-      // Silently ensure v3.0 directories exist (backfill for upgrades)
-      const ideasStates = ['pending', 'rejected', 'done'];
-      for (const st of ideasStates) {
-        fs.mkdirSync(path.join(getPlanningRoot(cwd), 'ideas', st), { recursive: true });
-      }
-      fs.mkdirSync(path.join(getPlanningRoot(cwd), 'specs'), { recursive: true });
-      fs.mkdirSync(path.join(getPlanningRoot(cwd), 'docs', 'product'), { recursive: true });
-      error('Product already initialized. Use /dgs:progress to see status.');
-    }
-  } else {
-    // ── Standard layout: existing v1/v2 checks ────────────────────────────
-    // Check if user previously declined v1-to-v2 migration
-    const configPath = path.join(getPlanningRoot(cwd), 'config.json');
-    let existingConfig = {};
-    try {
-      existingConfig = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-    } catch { /* no config yet */ }
-    if (existingConfig.v1_decline_migration) {
-      output({
-        v1_declined: true,
-        message: 'v1 mode preserved (migration was previously declined). Your v1 setup continues to work unchanged.',
-      }, raw);
-      return;
-    }
-
-    // Check for v1 install (existing .planning/PROJECT.md without v2 markers)
-    const v1Check = migration().detectV1Install(cwd);
-    if (v1Check.isV1) {
-      // Return v1 detection info — workflow handles the user prompt
-      output({
-        v1_detected: true,
-        project_name: v1Check.projectName,
-        slug: v1Check.slug,
-      }, raw);
-      return;
-    }
-
-    // Check if already v2
-    if (isV2Install(cwd)) {
-      // Silently ensure v3.0 directories exist (backfill for upgrades)
-      const ideasStates = ['pending', 'rejected', 'done'];
-      for (const st of ideasStates) {
-        fs.mkdirSync(path.join(getPlanningRoot(cwd), 'ideas', st), { recursive: true });
-      }
-      fs.mkdirSync(path.join(getPlanningRoot(cwd), 'specs'), { recursive: true });
-      fs.mkdirSync(path.join(getPlanningRoot(cwd), 'docs', 'product'), { recursive: true });
-      // Add .gitkeep files if directories are empty
-      const dirsToKeep = [
-        path.join(getPlanningRoot(cwd), 'ideas', 'pending', '.gitkeep'),
-        path.join(getPlanningRoot(cwd), 'ideas', 'rejected', '.gitkeep'),
-        path.join(getPlanningRoot(cwd), 'ideas', 'done', '.gitkeep'),
-        path.join(getPlanningRoot(cwd), 'specs', '.gitkeep'),
-        path.join(getPlanningRoot(cwd), 'docs', 'product', '.gitkeep'),
-      ];
-      for (const gk of dirsToKeep) {
-        if (!fs.existsSync(gk)) {
-          fs.writeFileSync(gk, '', 'utf-8');
-        }
-      }
-      error('Product already initialized. Use /dgs:progress to see status.');
+  // Write config.local.json FIRST so getPlanningRoot returns repo root
+  const rootLocalConfigPath = path.join(cwd, 'config.local.json');
+  fs.writeFileSync(rootLocalConfigPath, JSON.stringify({}, null, 2));
+  // Write empty shared config.json at root
+  const rootSharedConfigPath = path.join(cwd, 'config.json');
+  if (!fs.existsSync(rootSharedConfigPath)) {
+    fs.writeFileSync(rootSharedConfigPath, JSON.stringify({}, null, 2));
+  }
+  resetPaths(); // Clear stale cache so getPlanningRoot resolves to cwd
+
+  // Check if already initialized (idempotency)
+  if (isV2Install(cwd)) {
+    // Silently ensure v3.0 directories exist (backfill for upgrades)
+    const ideasStates = ['pending', 'rejected', 'done'];
+    for (const st of ideasStates) {
+      fs.mkdirSync(path.join(getPlanningRoot(cwd), 'ideas', st), { recursive: true });
     }
+    fs.mkdirSync(path.join(getPlanningRoot(cwd), 'specs'), { recursive: true });
+    fs.mkdirSync(path.join(getPlanningRoot(cwd), 'docs', 'product'), { recursive: true });
+    error('Product already initialized. Use /dgs:progress to see status.');
   }
 
-  // ── Shared scaffolding (layout-aware via getPlanningRoot) ─────────────────
-
-  // Ensure planning root exists (for standard layout creates .planning/; for root it's cwd)
+  // Planning root is cwd (root layout)
   fs.mkdirSync(getPlanningRoot(cwd), { recursive: true });
 
   // Create ideas, specs, and docs directories for v3.0 features
@@ -1270,52 +1159,27 @@ function cmdReposInitProduct(cwd, options, raw) {
   // Write REPOS.md
   writeReposMd(cwd, allRepos);
 
-  // Write PROJECTS.md (empty — no projects yet)
+  // Write PROJECTS.md (empty -- no projects yet)
   writeProjectsMd(cwd, []);
 
-  if (isRootMode) {
-    // Root-mode: generate .gitignore for root-layout repo
-    generateRootGitignore(cwd);
-
-    // Update config with product_name (config already exists from config-first step)
-    writeConfigField(cwd, 'product_name', productName);
-
-    output({
-      initialized: true,
-      layout: 'root',
-      product_name: productName,
-      repos_found: allRepos.length,
-      repos: allRepos,
-      needs_git_init: needsGitInit,
-      ideas_dirs_created: true,
-      specs_dir_created: true,
-      docs_dir_created: true,
-      files_created: ['config.json', 'config.local.json', 'REPOS.md', 'PROJECTS.md', 'ideas/', 'specs/', 'docs/', '.gitignore', 'review-keys.json'],
-    }, raw);
-  } else {
-    // Standard layout: sync .gitignore for local repo paths
-    const localPaths = allRepos.map(r => r.path).filter(p => p.startsWith('./'));
-    if (localPaths.length > 0) {
-      syncGitignore(cwd, localPaths);
-    }
+  // Generate .gitignore for root-layout repo
+  generateRootGitignore(cwd);
 
-    // Update config with product_name
-    writeConfigField(cwd, 'product_name', productName);
-
-    output({
-      initialized: true,
-      layout: 'dotplanning',
-      product_name: productName,
-      repos_found: allRepos.length,
-      repos: allRepos,
-      needs_git_init: needsGitInit,
-      gitignore_synced: localPaths.length > 0,
-      ideas_dirs_created: true,
-      specs_dir_created: true,
-      docs_dir_created: true,
-      files_created: ['.planning/', '.planning/REPOS.md', '.planning/PROJECTS.md', '.planning/ideas/', '.planning/specs/', '.planning/docs/', '.planning/review-keys.json'],
-    }, raw);
-  }
+  // Update config with product_name (config already exists from config-first step)
+  writeConfigField(cwd, 'product_name', productName);
+
+  output({
+    initialized: true,
+    layout: 'root',
+    product_name: productName,
+    repos_found: allRepos.length,
+    repos: allRepos,
+    needs_git_init: needsGitInit,
+    ideas_dirs_created: true,
+    specs_dir_created: true,
+    docs_dir_created: true,
+    files_created: ['config.json', 'config.local.json', 'REPOS.md', 'PROJECTS.md', 'ideas/', 'specs/', 'docs/', '.gitignore', 'review-keys.json'],
+  }, raw);
 }
 
 /**