create-sdd-project 0.17.1 → 0.17.3

package/lib/adapt-agents.js

@@ -227,7 +227,8 @@ function adaptAgentContentForProjectType(dest, config, replaceInFileFn) {
   // WORKFLOW_CORE_PROJECT_TYPE_RULES table above so upgrade-generator.js
   // can apply the same rules in-memory (smart-diff fallback comparison).
   // pr-template.md + AGENTS.md + base-standards.mdc remain inline because
-  // they're not workflow-core files (pr-template is v0.17.2 scope).
+  // they're not workflow-core files (pr-template is out of scope for v0.17.1 —
+  // see dev/ROADMAP.md "Known follow-ups" item 2).
   const wfRules = WORKFLOW_CORE_PROJECT_TYPE_RULES[config.projectType];
   if (wfRules) {
     for (const dir of toolDirs) {
@@ -243,7 +244,8 @@ function adaptAgentContentForProjectType(dest, config, replaceInFileFn) {
       [', `ui-ux-designer`', ''],
     ]);
     for (const dir of toolDirs) {
-      // pr-template: remove ui-components from checklist (v0.17.2 scope)
+      // pr-template: remove ui-components from checklist (out of scope for
+      // v0.17.1 — see dev/ROADMAP.md "Known follow-ups" item 2)
       replaceInFileFn(path.join(dest, dir, 'skills', 'development-workflow', 'references', 'pr-template.md'), [
         [' / ui-components.md', ''],
       ]);

package/lib/init-generator.js

@@ -232,10 +232,32 @@ function generateInit(config) {
   console.log('    These files were generated from project analysis. Adjust patterns');
   console.log('    and conventions to match your team\'s actual practices.');
 
-  // Test coverage note
-  if (scan.tests.estimatedCoverage === 'none' || scan.tests.estimatedCoverage === 'low') {
+  // Test coverage note — v0.17.3: broaden signal detection across root,
+  // backend, and frontend tests (covers E2E-only setups and monorepos
+  // with workspace-level tests). Only show the note when NO test signal
+  // exists anywhere.
+  const hasAnyTestSignal =
+    scan.tests.framework !== 'none' ||
+    scan.backendTests.framework !== 'none' ||
+    scan.frontendTests.framework !== 'none' ||
+    scan.tests.e2eFramework !== null ||
+    scan.tests.testFiles > 0 ||
+    scan.backendTests.testFiles > 0 ||
+    scan.frontendTests.testFiles > 0;
+  const maxCoverageRank = (c) =>
+    c === 'high' ? 3 : c === 'medium' ? 2 : c === 'low' ? 1 : 0;
+  const bestCoverage = Math.max(
+    maxCoverageRank(scan.tests.estimatedCoverage),
+    maxCoverageRank(scan.backendTests.estimatedCoverage),
+    maxCoverageRank(scan.frontendTests.estimatedCoverage),
+  );
+  if (!hasAnyTestSignal || bestCoverage <= 1 /* none or low */) {
     console.log('');
-    const fileCount = scan.tests.testFiles;
+    const fileCount = Math.max(
+      scan.tests.testFiles,
+      scan.backendTests.testFiles,
+      scan.frontendTests.testFiles,
+    );
     if (fileCount === 0) {
       console.log('  📝 No test files detected.');
     } else {
@@ -458,8 +480,11 @@ function adaptBackendStandards(template, scan) {
   const db = scan.backend.db;
   const lang = scan.language === 'typescript' ? 'TypeScript' : 'JavaScript';
 
-  const testFramework = scan.tests.framework !== 'none'
-    ? capitalizeFramework(scan.tests.framework)
+  // v0.17.3: consume backendTests instead of tests so that monorepos with
+  // workspace-only test frameworks (e.g., fx: vitest in packages/api) emit
+  // the correct Testing line. Single-package: backendTests === tests.
+  const testFramework = scan.backendTests.framework !== 'none'
+    ? capitalizeFramework(scan.backendTests.framework)
     : 'Not configured';
 
   let stackLines = [
@@ -570,9 +595,14 @@ function adaptFrontendStandards(template, scan) {
   const state = scan.frontend.state ? `, ${scan.frontend.state}` : '';
   const lang = scan.language === 'typescript' ? 'TypeScript' : 'JavaScript';
 
+  // v0.17.3: consume frontendTests (see backend equivalent above).
+  const frontendTestFramework = scan.frontendTests.framework !== 'none'
+    ? capitalizeFramework(scan.frontendTests.framework)
+    : 'Not configured';
+
   content = content.replace(
     /## Technology Stack\n\n[\s\S]*?(?=\n## Project Structure)/,
-    `## Technology Stack\n\n- **Framework**: ${framework}\n- **Language**: ${lang}\n- **Styling**: ${styling}${components ? `\n- **Components**: ${components.slice(2)}` : ''}${state ? `\n- **State Management**: ${state.slice(2)}` : ''}\n- **Testing**: ${scan.tests.framework !== 'none' ? capitalizeFramework(scan.tests.framework) : 'Not configured'}\n\n`
+    `## Technology Stack\n\n- **Framework**: ${framework}\n- **Language**: ${lang}\n- **Styling**: ${styling}${components ? `\n- **Components**: ${components.slice(2)}` : ''}${state ? `\n- **State Management**: ${state.slice(2)}` : ''}\n- **Testing**: ${frontendTestFramework}\n\n`
   );
 
   // Update Project Structure
@@ -848,8 +878,29 @@ function configureProductTracker(template, scan) {
     content = content.replace('| backend | pending', `| ${featureType} | pending`);
   }
 
-  // Add retrofit testing as first feature if coverage is low
-  if (scan.tests.estimatedCoverage === 'none' || scan.tests.estimatedCoverage === 'low') {
+  // Add retrofit testing as first feature if coverage is low — v0.17.3
+  // broaden the gate: consider backend and frontend test coverage, not just
+  // root-level. Avoids false F001 recommendation on monorepos that have
+  // extensive tests in workspaces. Per Gemini round-3 CRITICAL: also gate
+  // on the broader "any test signal" disjunction so E2E-only setups
+  // (Playwright/Cypress at root, no unit tests anywhere) don't trigger
+  // F001 either — symmetric with the console-warning gate above.
+  const rankCoverage = (c) =>
+    c === 'high' ? 3 : c === 'medium' ? 2 : c === 'low' ? 1 : 0;
+  const bestCov = Math.max(
+    rankCoverage(scan.tests.estimatedCoverage),
+    rankCoverage(scan.backendTests.estimatedCoverage),
+    rankCoverage(scan.frontendTests.estimatedCoverage),
+  );
+  const hasAnyTestSignal =
+    scan.tests.framework !== 'none' ||
+    scan.backendTests.framework !== 'none' ||
+    scan.frontendTests.framework !== 'none' ||
+    scan.tests.e2eFramework !== null ||
+    scan.tests.testFiles > 0 ||
+    scan.backendTests.testFiles > 0 ||
+    scan.frontendTests.testFiles > 0;
+  if (!hasAnyTestSignal || bestCov <= 1 /* none or low */) {
     // Use regex to match the F001 placeholder row resiliently (handles column changes)
     content = content.replace(
       /\| F001 \|[^\n]*\n/,

package/lib/init-wizard.js

@@ -41,8 +41,23 @@ function formatScanSummary(scanResult) {
   };
   lines.push(`    Architecture:  ${patternLabels[scanResult.srcStructure.pattern] || 'Unknown'}`);
 
-  if (scanResult.tests.framework !== 'none') {
-    lines.push(`    Tests:         ${scanResult.tests.framework} (${scanResult.tests.testFiles} test files)`);
+  // v0.17.3: collect distinct non-'none' frameworks across root, backend,
+  // and frontend tests. For mixed monorepos (e.g., fx: vitest in api, jest
+  // in web), display joined (e.g., "vitest + jest") so the summary reflects
+  // what adapt-functions will actually write. Avoids the v1.1 UX issue
+  // where OR-precedence picked root-hoisted jest over workspace vitest.
+  const uniqueFrameworks = Array.from(new Set([
+    scanResult.tests.framework,
+    scanResult.backendTests.framework,
+    scanResult.frontendTests.framework,
+  ].filter((f) => f !== 'none')));
+  if (uniqueFrameworks.length > 0) {
+    const totalFiles = Math.max(
+      scanResult.tests.testFiles,
+      scanResult.backendTests.testFiles,
+      scanResult.frontendTests.testFiles,
+    );
+    lines.push(`    Tests:         ${uniqueFrameworks.join(' + ')} (${totalFiles} test files)`);
   } else {
     lines.push('    Tests:         None detected');
   }

package/lib/meta.js

@@ -236,9 +236,10 @@ function writeMeta(dest, hashes) {
  * - 6 workflow-core files (development-workflow SKILL.md + ticket-template.md
  *   + merge-checklist.md, × 2 tools) — filtered by aiTools
  *
- * Out of scope for v0.17.1 (deferred to v0.17.2): bug-workflow/SKILL.md,
- * health-check/SKILL.md, pm-orchestrator/SKILL.md, project-memory/SKILL.md,
- * and all references/ files except the 3 development-workflow ones above.
+ * Out of scope for v0.17.1 (deferred — see dev/ROADMAP.md "Known follow-ups"
+ * item 2): bug-workflow/SKILL.md, health-check/SKILL.md, pm-orchestrator/SKILL.md,
+ * project-memory/SKILL.md, and all references/ files except the 3
+ * development-workflow ones above. Did not land in the v0.17.2 scanner hotfix.
  */
 function expectedSmartDiffTrackedPaths(aiTools, projectType) {
   const paths = new Set();
@@ -273,7 +274,7 @@ function expectedSmartDiffTrackedPaths(aiTools, projectType) {
 
   // v0.17.1: development-workflow skill core files — filtered by aiTools.
   // bug-workflow, health-check, pm-orchestrator, project-memory are OUT OF
-  // SCOPE for v0.17.1 (deferred to v0.17.2).
+  // SCOPE for v0.17.1 (deferred — see dev/ROADMAP.md "Known follow-ups" item 2).
   for (const dir of toolDirs) {
     paths.add(`${dir}/skills/development-workflow/SKILL.md`);
     paths.add(`${dir}/skills/development-workflow/references/ticket-template.md`);

package/lib/scanner.js

@@ -8,18 +8,36 @@ const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.next', '.n
 /**
  * Scan an existing project directory and return detected configuration.
  *
- * v0.17.1: monorepo-aware. If the root `package.json` does not yield a
- * backend/frontend detection AND the project is a monorepo with
- * `package.json#workspaces`, enumerate workspace `package.json` files in
- * declaration order (pattern outer, lexical inner, deduped by normalized
- * path) and run `detectBackend` / `detectFrontend` per workspace. The
- * FIRST workspace returning `detected: true` wins and its result is merged
+ * v0.17.1: monorepo-aware. If the project is a monorepo with
+ * `package.json#workspaces` and the root `package.json` does not yield a
+ * complete backend/frontend detection, enumerate workspace `package.json`
+ * files in declaration order (pattern outer, lexical inner, deduped by
+ * normalized path) and run `detectBackend` / `detectFrontend` per workspace.
+ * The FIRST workspace returning a framework wins and its result is merged
  * into `result.backend` / `result.frontend` with a `workspaceSource` field
  * recording the detected workspace's relative path (for diagnostics).
  *
- * Scanner additive invariant (v0.17.1): for single-package projects, or
- * monorepos where root detection already succeeded, the workspace
- * enumeration never fires and the result is byte-identical to v0.17.0.
+ * v0.17.2: the "complete detection" gate uses `framework` presence, not
+ * the older `detected` flag. This is because `detectBackend` has a
+ * partial-detection fallback (see `detectBackend` lines ~259-261) that
+ * sets `detected: true` when only `db` or `orm` is found — commonly
+ * triggered by a ROOT `.env.example` declaring `DATABASE_URL` + `PORT`
+ * in a monorepo whose real backend stack lives under `packages/api`.
+ * Under the v0.17.1 guard, that partial detection blocked the workspace
+ * enumeration and left `backend.framework` null → `adaptBackendStandards`
+ * produced generic placeholders → `adaptAgentsMd` fell back to the
+ * `(DDD, Express, Prisma)` template literal. Gating on `!framework`
+ * fires the enumeration in that case and correctly promotes
+ * workspace-level framework/orm info while preserving root-level
+ * env-derived fields (`db`, `port`) that the workspace didn't detect.
+ *
+ * Scanner additive invariant: for single-package projects, `isMonorepo`
+ * is false and the enumeration block is skipped entirely — same behavior
+ * as v0.17.0 and v0.17.1, byte-identical output. For monorepos, the
+ * v0.17.2 gate is strictly looser than v0.17.1's, so it runs the
+ * enumeration in a strict superset of cases. Enumeration only adds
+ * info (framework/orm from workspace), never removes it. Therefore
+ * v0.17.2 scan output ⊇ v0.17.1 scan output for the same input.
  */
 function scan(projectDir) {
   const pkg = readPackageJson(projectDir);
@@ -28,44 +46,187 @@ function scan(projectDir) {
   const frontend = detectFrontend(projectDir, pkg);
   const isMonorepo = detectMonorepo(projectDir, pkg);
 
-  // v0.17.1 monorepo fallback
-  if (isMonorepo && (!backend.detected || !frontend.detected)) {
+  let language = detectLanguage(projectDir);
+  let srcStructure = detectArchitecture(projectDir, pkg);
+  const rootTests = detectTests(projectDir, pkg);
+  let backendTests = rootTests;
+  let frontendTests = rootTests;
+
+  // v0.17.3: single-pass monorepo enumeration.
+  //
+  // Combines v0.17.2's framework promotion (runs only when root lacks a
+  // framework, gated by `!backend.framework` / `!frontend.framework`) with
+  // v0.17.3's auxiliary-field promotion (language, architecture, tests,
+  // frontend styling/components/state) into a single loop that always runs
+  // in monorepos.
+  //
+  // Rationale for always-enumerate: `workspaceSource` is only set when
+  // v0.17.2 actually promoted a framework from a workspace (root lacked it).
+  // If root has the framework hoisted (e.g., `"next": "^14.2.29"` at root in
+  // a Next.js monorepo), v0.17.2's loop never runs → `workspaceSource` is
+  // null → auxiliary detection has no workspace handle. v0.17.3 solves this
+  // by tracking `primaryBackendWs` / `primaryFrontendWs` independently:
+  // always populated for monorepos with a detectable backend/frontend
+  // workspace, regardless of where the framework came from. See
+  // dev/v0.17.3-plan.md D5 for full rationale + round-1/round-2 review trail.
+  let primaryBackendWs = null;
+  let primaryFrontendWs = null;
+  if (isMonorepo) {
     const workspaces = enumerateWorkspaces(projectDir, pkg);
     for (const wsRel of workspaces) {
       const wsAbs = path.join(projectDir, ...wsRel.split('/'));
       const wsPkg = readPackageJson(wsAbs);
-      if (!backend.detected) {
+
+      if (!primaryBackendWs) {
         const wsBackend = detectBackend(wsAbs, wsPkg);
-        if (wsBackend.detected) {
-          Object.assign(backend, wsBackend, { workspaceSource: wsRel });
+        if (wsBackend.framework) {
+          primaryBackendWs = wsRel;
+          // v0.17.2 promotion — only when root lacked framework. Preserves
+          // v0.17.2 semantics byte-equivalent.
+          if (!backend.framework) {
+            for (const field of Object.keys(wsBackend)) {
+              if (wsBackend[field] !== null && wsBackend[field] !== undefined) {
+                backend[field] = wsBackend[field];
+              }
+            }
+            backend.workspaceSource = wsRel;
+          }
         }
       }
-      if (!frontend.detected) {
+
+      if (!primaryFrontendWs) {
         const wsFrontend = detectFrontend(wsAbs, wsPkg);
-        if (wsFrontend.detected) {
-          Object.assign(frontend, wsFrontend, { workspaceSource: wsRel });
+        if (wsFrontend.framework) {
+          primaryFrontendWs = wsRel;
+          if (!frontend.framework) {
+            for (const field of Object.keys(wsFrontend)) {
+              if (wsFrontend[field] !== null && wsFrontend[field] !== undefined) {
+                frontend[field] = wsFrontend[field];
+              }
+            }
+            frontend.workspaceSource = wsRel;
+          }
+        }
+      }
+
+      if (primaryBackendWs && primaryFrontendWs) break;
+    }
+
+    // v0.17.3 auxiliary detection — runs whenever a primary workspace was
+    // identified, independent of v0.17.2 promotion.
+    if (primaryBackendWs) {
+      const wsAbs = path.join(projectDir, ...primaryBackendWs.split('/'));
+      const wsPkg = readPackageJson(wsAbs);
+      // D1: scalar language merge — TypeScript wins over JavaScript, never
+      // demote. 'javascript' is detectLanguage's default; if the workspace
+      // returns 'typescript', promote.
+      if (detectLanguage(wsAbs) === 'typescript') language = 'typescript';
+      // D2: architecture per-field merge.
+      // - pattern: workspace wins if it detected ANY known pattern (any
+      //   non-'unknown' value). Strict non-demotion: workspace 'unknown'
+      //   never demotes a known root pattern. Workspace known-vs-known
+      //   resolves to workspace because the workspace is the authoritative
+      //   source for the primary backend's organization (root pattern in
+      //   monorepos is often a false signal from the listing fallback when
+      //   no src/ exists).
+      // - dirs: workspace wins when it has any dirs (root's empty []
+      //   carries no info, and root in monorepos lists workspace dirs not
+      //   source dirs which is misleading).
+      // - boolean hasX flags: OR-merge (true wins, never demoted from true).
+      const wsArch = detectArchitecture(wsAbs, wsPkg);
+      if (wsArch.pattern !== 'unknown') srcStructure.pattern = wsArch.pattern;
+      if (wsArch.dirs && wsArch.dirs.length > 0) srcStructure.dirs = wsArch.dirs;
+      for (const field of [
+        'hasControllers',
+        'hasRoutes',
+        'hasModels',
+        'hasServices',
+        'hasDomain',
+        'hasMiddleware',
+        'hasFeatures',
+        'hasHandlers',
+      ]) {
+        if (wsArch[field] === true) srcStructure[field] = true;
+      }
+      // D3: backend tests per-field merge (preserves root-level E2E).
+      backendTests = mergeWorkspaceTests(rootTests, detectTests(wsAbs, wsPkg));
+    }
+
+    if (primaryFrontendWs) {
+      const wsAbs = path.join(projectDir, ...primaryFrontendWs.split('/'));
+      const wsPkg = readPackageJson(wsAbs);
+      // D4 (revised): promote auxiliary frontend fields (styling,
+      // components, state) from the primary frontend workspace,
+      // independent of whether the framework was promoted at root.
+      const wsFrontendAux = detectFrontend(wsAbs, wsPkg);
+      for (const field of ['styling', 'components', 'state']) {
+        if (wsFrontendAux[field] !== null && wsFrontendAux[field] !== undefined) {
+          frontend[field] = wsFrontendAux[field];
         }
       }
-      if (backend.detected && frontend.detected) break;
+      frontendTests = mergeWorkspaceTests(rootTests, detectTests(wsAbs, wsPkg));
     }
+
+    // D5 observability: export primary workspace identifiers for diagnostics
+    // and smoke-test assertions. `workspaceSource` (v0.17.2) remains set only
+    // when promotion happened; `primaryWorkspace` (v0.17.3) is set whenever a
+    // workspace was used for aux detection.
+    if (primaryBackendWs) backend.primaryWorkspace = primaryBackendWs;
+    if (primaryFrontendWs) frontend.primaryWorkspace = primaryFrontendWs;
   }
 
   return {
     projectName: pkg.name || path.basename(projectDir),
     description: pkg.description || '',
-    language: detectLanguage(projectDir),
+    language,
     backend,
     frontend,
     isMonorepo,
     rootDirs: listRootDirs(projectDir),
-    srcStructure: detectArchitecture(projectDir, pkg),
-    tests: detectTests(projectDir, pkg),
+    srcStructure,
+    tests: rootTests,
+    backendTests,
+    frontendTests,
     existingDocs: detectExistingDocs(projectDir),
     gitBranch: detectGitBranch(projectDir),
     hasGit: fs.existsSync(path.join(projectDir, '.git')),
   };
 }
 
+/**
+ * v0.17.3: per-field merge of workspace test detection results into a
+ * new object based on root-level test detection.
+ *
+ * Preserves root-level signals the workspace doesn't see:
+ *   - e2eFramework (Playwright/Cypress typically installed once at root)
+ *   - framework (if workspace found no unit framework, keep root's default
+ *     or hoisted value)
+ *
+ * Promotes workspace signals that override root:
+ *   - framework: workspace wins if it detected a non-'none' unit framework
+ *   - hasConfig: logical OR (either source)
+ *   - testFiles / testDirs / estimatedCoverage: workspace authoritative when
+ *     it saw any test files. (Note: `countFilesRecursive` walks from
+ *     projectDir up to depth 6 traversing into packages/*, so rootTests
+ *     already aggregates workspace counts. A comparison like
+ *     `wsTests.testFiles > rootTests.testFiles` would be dead code — see
+ *     dev/v0.17.3-plan.md D3 v1.2 revision.)
+ */
+function mergeWorkspaceTests(rootTests, wsTests) {
+  const merged = { ...rootTests };
+  if (wsTests.framework !== 'none') {
+    merged.framework = wsTests.framework;
+    merged.hasConfig = wsTests.hasConfig || rootTests.hasConfig;
+  }
+  if (wsTests.testFiles > 0) {
+    merged.testFiles = wsTests.testFiles;
+    merged.testDirs = wsTests.testDirs;
+    merged.estimatedCoverage = wsTests.estimatedCoverage;
+  }
+  if (wsTests.e2eFramework) merged.e2eFramework = wsTests.e2eFramework;
+  return merged;
+}
+
 /**
  * v0.17.1: enumerate workspace paths declared in `pkg.workspaces`.
  *
@@ -76,7 +237,8 @@ function scan(projectDir) {
  *  - Single-wildcard patterns: `"packages/*"` (expand immediate subdirs)
  *
  * Does NOT support: `**` recursive patterns, `!exclude` negation, or
- * `pnpm-workspace.yaml` — all deferred to v0.17.2.
+ * `pnpm-workspace.yaml` — all deferred (see dev/ROADMAP.md "Known follow-ups"
+ * item 3). Did not land in the v0.17.2 scanner hotfix.
  *
  * Returns a deterministic, deduplicated array of POSIX-style relative
  * workspace paths. Ordering: outer = declaration order of patterns; inner

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-sdd-project",
-  "version": "0.17.1",
+  "version": "0.17.3",
   "description": "Create a new SDD DevFlow project with AI-assisted development workflow",
   "bin": {
     "create-sdd-project": "bin/cli.js"