create-sdd-project 0.17.1 → 0.17.2

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,25 +46,43 @@ function scan(projectDir) {
   const frontend = detectFrontend(projectDir, pkg);
   const isMonorepo = detectMonorepo(projectDir, pkg);
 
-  // v0.17.1 monorepo fallback
-  if (isMonorepo && (!backend.detected || !frontend.detected)) {
+  // v0.17.2 monorepo fallback: promote to workspace when root lacks a
+  // framework, even if root partial detection set `detected: true`.
+  if (isMonorepo && (!backend.framework || !frontend.framework)) {
     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 (!backend.framework) {
         const wsBackend = detectBackend(wsAbs, wsPkg);
-        if (wsBackend.detected) {
-          Object.assign(backend, wsBackend, { workspaceSource: wsRel });
+        if (wsBackend.framework) {
+          // Field-merge: prefer workspace values for fields it detected,
+          // preserve root values for fields the workspace didn't (e.g.,
+          // a root .env's DATABASE_URL → root.db, which packages/api
+          // might not repeat in its own .env). Iterate `Object.keys` so
+          // future additions to `detectBackend` are forwarded without
+          // requiring a dual-update here (Gemini round-4 finding 1).
+          // `workspaceSource` records the winning workspace for diagnostics.
+          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 (!frontend.framework) {
         const wsFrontend = detectFrontend(wsAbs, wsPkg);
-        if (wsFrontend.detected) {
-          Object.assign(frontend, wsFrontend, { workspaceSource: wsRel });
+        if (wsFrontend.framework) {
+          for (const field of Object.keys(wsFrontend)) {
+            if (wsFrontend[field] !== null && wsFrontend[field] !== undefined) {
+              frontend[field] = wsFrontend[field];
+            }
+          }
+          frontend.workspaceSource = wsRel;
         }
       }
-      if (backend.detected && frontend.detected) break;
+      if (backend.framework && frontend.framework) break;
     }
   }
 

package/package.json

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