sdd-cli 0.1.25 → 0.1.27

package/dist/commands/ai-autopilot.js

@@ -146,6 +146,66 @@ function detectBaselineKind(intent) {
     }
     return "generic";
 }
+function normalizeIntentText(intent) {
+    return intent
+        .toLowerCase()
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "");
+}
+function intentRequiresJavaReactFullstack(intent) {
+    const lower = normalizeIntentText(intent);
+    return /\bjava\b/.test(lower) && /\breact\b/.test(lower);
+}
+function intentSuggestsRelationalDataDomain(intent) {
+    const lower = normalizeIntentText(intent);
+    return [
+        "library",
+        "biblioteca",
+        "inventario",
+        "inventory",
+        "prestamo",
+        "prestamos",
+        "loan",
+        "loans",
+        "usuario",
+        "usuarios",
+        "user",
+        "users",
+        "book",
+        "books",
+        "cita",
+        "citas",
+        "appointment",
+        "appointments",
+        "hospital"
+    ].some((token) => lower.includes(token));
+}
+function extraPromptConstraints(intent) {
+    const constraints = [];
+    if (intentRequiresJavaReactFullstack(intent)) {
+        constraints.push("Use split structure: backend/ (Java Spring Boot) and frontend/ (React + Vite).");
+        constraints.push("Backend must expose REST APIs for users, books, loans, and inventory.");
+        constraints.push("Frontend must consume backend APIs (do not keep data only in static mocks).");
+        constraints.push("Use modern React data layer: @tanstack/react-query (not react-query).");
+        constraints.push("Backend architecture must include DTO classes, service interfaces, and repository interfaces.");
+        constraints.push("Use Java records for immutable request/response or transport models.");
+        constraints.push("Use Lombok in backend entities/DTOs where appropriate (builder/getter/setter/constructor patterns).");
+        constraints.push("Use Jakarta/Javax Bean Validation annotations and @Valid in request boundaries.");
+        constraints.push("Include @RestControllerAdvice for global exception handling.");
+        constraints.push("Add Spring Actuator telemetry and basic Prometheus-friendly metrics configuration.");
+        constraints.push("Frontend architecture must include src/api, src/hooks (use*.ts/tsx), and src/components layers.");
+        constraints.push("Frontend bootstrap must use React.StrictMode.");
+        constraints.push("Frontend should include safe input validation and avoid direct unsafe HTML rendering.");
+        constraints.push("Include frontend tests and backend tests that run in local CI.");
+        constraints.push("Include architecture.md and execution-guide.md with clear local run instructions.");
+    }
+    if (intentSuggestsRelationalDataDomain(intent)) {
+        constraints.push("Use a scalable relational database default (prefer PostgreSQL).");
+        constraints.push("Include SQL schema file named schema.sql (or db/schema.sql) with tables, keys, indexes, and constraints.");
+        constraints.push("Document local database strategy in README and DummyLocal docs.");
+    }
+    return constraints;
+}
 function commonPackageJson(projectName) {
     return `{
   "name": "${projectName.toLowerCase().replace(/[^a-z0-9-]+/g, "-")}",
@@ -1087,12 +1147,14 @@ function bootstrapProjectCode(projectRoot, projectName, intent, providerRequeste
     let files = [];
     let fallbackReason;
     if (resolution.ok) {
+        const constraints = extraPromptConstraints(intent);
         const prompt = [
             "Generate a production-lean starter app from user intent.",
             "The project must be executable fully in local development.",
             "Use DummyLocal adapters for integrations (databases, external APIs, queues) so everything runs locally.",
             "Add a schema document named schemas.md with entities, fields, relations, and constraints.",
             "Add regression tests and regression notes/documentation.",
+            ...constraints,
             "Do not mix unrelated runtime stacks unless the intent explicitly requests a multi-tier architecture.",
             "Return ONLY valid JSON with this shape:",
             '{"files":[{"path":"relative/path","content":"file content"}],"run_command":"...","deploy_steps":["..."],"publish_steps":["..."]}',
@@ -1120,11 +1182,13 @@ function bootstrapProjectCode(projectRoot, projectName, intent, providerRequeste
             }
         }
         if (files.length === 0) {
+            const fallbackConstraints = extraPromptConstraints(intent);
             const fallbackPrompt = [
                 "Return ONLY valid JSON. No markdown.",
                 "Schema: {\"files\":[{\"path\":\"relative/path\",\"content\":\"...\"}]}",
                 "Generate only essential starter files to run locally with quality-first defaults.",
                 "Must include: README.md, schemas.md, regression notes, and DummyLocal integration docs.",
+                ...fallbackConstraints,
                 `Project: ${projectName}`,
                 `Intent: ${intent}`
             ].join("\n");
@@ -1186,7 +1250,7 @@ function bootstrapProjectCode(projectRoot, projectName, intent, providerRequeste
     };
 }
 function compactFilesForPrompt(files) {
-    const maxFiles = 12;
+    const maxFiles = 8;
     const maxChars = 700;
     return files.slice(0, maxFiles).map((file) => ({
         path: file.path,
@@ -1231,6 +1295,12 @@ function improveGeneratedApp(appDir, intent, providerRequested, qualityDiagnosti
         return { attempted: false, applied: false, fileCount: 0, reason: "provider unavailable" };
     }
     const currentFiles = compactFilesForPrompt(collectProjectFiles(appDir));
+    const compactDiagnostics = (qualityDiagnostics ?? [])
+        .map((line) => line.replace(/\u001b\[[0-9;]*m/g, "").replace(/\s+/g, " ").trim())
+        .filter((line) => line.length > 0)
+        .slice(0, 8)
+        .map((line) => (line.length > 280 ? `${line.slice(0, 280)}...[truncated]` : line));
+    const constraints = extraPromptConstraints(intent);
     const prompt = [
         "Improve this generated app to production-lean quality.",
         "Requirements:",
@@ -1238,17 +1308,19 @@ function improveGeneratedApp(appDir, intent, providerRequested, qualityDiagnosti
         "- Ensure tests pass for the selected stack.",
         "- Ensure code is clear and maintainable.",
         "- Ensure schemas.md exists and documents data schemas.",
+        "- Ensure relational-data apps include schema.sql with proper keys/indexes.",
         "- Ensure DummyLocal integration exists and is documented.",
         "- Ensure regression tests (or explicit regression test documentation) exists.",
+        ...constraints.map((line) => `- ${line}`),
         "- Fix every listed quality diagnostic failure.",
         "Return ONLY JSON with shape:",
         '{"files":[{"path":"relative/path","content":"full file content"}]}',
         `Intent: ${intent}`,
-        `Quality diagnostics: ${JSON.stringify(qualityDiagnostics ?? [])}`,
+        `Quality diagnostics: ${JSON.stringify(compactDiagnostics)}`,
         `Current files JSON: ${JSON.stringify(currentFiles)}`
     ].join("\n");
     let parsed = askProviderForJson(resolution.provider.exec, prompt);
-    if ((!parsed || !Array.isArray(parsed.files)) && Array.isArray(qualityDiagnostics) && qualityDiagnostics.length > 0) {
+    if ((!parsed || !Array.isArray(parsed.files)) && compactDiagnostics.length > 0) {
         const fileNames = collectProjectFiles(appDir).map((f) => f.path).slice(0, 120);
         const targetedPrompt = [
             "Return ONLY valid JSON. No markdown.",
@@ -1256,11 +1328,22 @@ function improveGeneratedApp(appDir, intent, providerRequested, qualityDiagnosti
             "Fix exactly the listed quality diagnostics with minimal file edits.",
             "If diagnostics mention missing docs/tests, generate them.",
             `Intent: ${intent}`,
-            `Quality diagnostics: ${JSON.stringify(qualityDiagnostics)}`,
+            `Quality diagnostics: ${JSON.stringify(compactDiagnostics)}`,
             `Current file names: ${JSON.stringify(fileNames)}`
         ].join("\n");
         parsed = askProviderForJson(resolution.provider.exec, targetedPrompt);
     }
+    if (!parsed || !Array.isArray(parsed.files)) {
+        const minimalPrompt = [
+            "Return ONLY valid JSON. No markdown.",
+            'Schema: {"files":[{"path":"relative/path","content":"..."}]}',
+            "Apply minimal patch set: 1 to 5 files only.",
+            "Prioritize fixing the first quality diagnostic immediately.",
+            `Intent: ${intent}`,
+            `Top quality diagnostics: ${JSON.stringify(compactDiagnostics.slice(0, 2))}`
+        ].join("\n");
+        parsed = askProviderForJson(resolution.provider.exec, minimalPrompt);
+    }
     if (!parsed || !Array.isArray(parsed.files)) {
         return { attempted: true, applied: false, fileCount: 0, reason: "provider response unusable" };
     }

package/dist/commands/app-lifecycle.js

@@ -9,6 +9,50 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
 const config_1 = require("../config");
+function collectFilesRecursive(root, maxDepth = 8) {
+    const results = [];
+    const walk = (current, depth) => {
+        if (depth > maxDepth) {
+            return;
+        }
+        const entries = fs_1.default.readdirSync(current, { withFileTypes: true });
+        for (const entry of entries) {
+            const full = path_1.default.join(current, entry.name);
+            const rel = path_1.default.relative(root, full).replace(/\\/g, "/");
+            if (entry.isDirectory()) {
+                if ([".git", "node_modules", "dist", "build", "target", "__pycache__", ".venv", "venv"].includes(entry.name.toLowerCase())) {
+                    continue;
+                }
+                walk(full, depth + 1);
+            }
+            else {
+                results.push(rel);
+            }
+        }
+    };
+    walk(root, 0);
+    return results;
+}
+function countJsTsTests(root, maxDepth = 8) {
+    const files = collectFilesRecursive(root, maxDepth)
+        .filter((rel) => /\.(jsx?|tsx?)$/i.test(rel))
+        .filter((rel) => /\.test\.|\.spec\.|__tests__\//i.test(rel));
+    let count = 0;
+    for (const rel of files) {
+        const raw = fs_1.default.readFileSync(path_1.default.join(root, rel), "utf-8");
+        count += (raw.match(/\b(test|it)\s*\(/g) || []).length;
+    }
+    return count;
+}
+function fileExistsAny(root, candidates) {
+    for (const candidate of candidates) {
+        const full = path_1.default.join(root, candidate);
+        if (fs_1.default.existsSync(full)) {
+            return full;
+        }
+    }
+    return null;
+}
 function findFileRecursive(root, predicate, maxDepth = 4) {
     const walk = (current, depth) => {
         if (depth > maxDepth) {
@@ -73,14 +117,21 @@ function countTestsRecursive(root, maxDepth = 8) {
 }
 function run(command, args, cwd) {
     let resolved = command;
-    if (process.platform === "win32" && command === "npm") {
-        resolved = "npm.cmd";
+    if (process.platform === "win32") {
+        if (command === "npm") {
+            resolved = "npm.cmd";
+        }
+        else if (command === "mvn") {
+            resolved = "mvn.cmd";
+        }
     }
     const useShell = process.platform === "win32" && resolved.toLowerCase().endsWith(".cmd");
     const result = useShell
         ? (0, child_process_1.spawnSync)([resolved, ...args].join(" "), { cwd, encoding: "utf-8", shell: true })
         : (0, child_process_1.spawnSync)(resolved, args, { cwd, encoding: "utf-8", shell: false });
-    const output = `${result.stdout || ""}${result.stderr || ""}`.trim();
+    const rawOutput = `${result.stdout || ""}${result.stderr || ""}`.trim();
+    const merged = rawOutput || (result.error ? String(result.error.message || result.error) : "");
+    const output = merged.length > 3500 ? `${merged.slice(0, 3500)}\n...[truncated]` : merged;
     return {
         ok: result.status === 0,
         command: [resolved, ...args].join(" "),
@@ -107,19 +158,58 @@ function runIfScript(cwd, script) {
         return null;
     }
 }
-function packageNeedsInstall(cwd) {
+function readPackageJson(cwd) {
     const pkgPath = path_1.default.join(cwd, "package.json");
     if (!fs_1.default.existsSync(pkgPath)) {
-        return false;
+        return null;
     }
     try {
-        const pkg = JSON.parse(fs_1.default.readFileSync(pkgPath, "utf-8"));
-        const depCount = Object.keys(pkg.dependencies ?? {}).length + Object.keys(pkg.devDependencies ?? {}).length;
-        return depCount > 0;
+        return JSON.parse(fs_1.default.readFileSync(pkgPath, "utf-8"));
     }
     catch {
+        return null;
+    }
+}
+function packageNeedsInstall(cwd) {
+    const pkg = readPackageJson(cwd);
+    if (!pkg) {
         return false;
     }
+    const depCount = Object.keys(pkg.dependencies ?? {}).length + Object.keys(pkg.devDependencies ?? {}).length;
+    return depCount > 0;
+}
+function parseGoalProfile(context) {
+    const goal = normalizeText(context?.goalText ?? "");
+    const hasJava = /\bjava\b/.test(goal);
+    const hasReact = /\breact\b/.test(goal);
+    const relationalHints = [
+        "library",
+        "biblioteca",
+        "inventario",
+        "inventory",
+        "prestamo",
+        "prestamos",
+        "loan",
+        "loans",
+        "usuario",
+        "usuarios",
+        "user",
+        "users",
+        "book",
+        "books",
+        "cita",
+        "citas",
+        "appointment",
+        "appointments",
+        "hospital",
+        "gestion",
+        "management"
+    ];
+    const relationalDataApp = relationalHints.some((hint) => goal.includes(hint));
+    return {
+        javaReactFullstack: hasJava && hasReact,
+        relationalDataApp
+    };
 }
 function basicQualityCheck(appDir) {
     const required = ["README.md"];
@@ -192,6 +282,207 @@ function advancedQualityCheck(appDir, context) {
             output: "Missing schemas.md (or equivalent schema markdown document)"
         };
     }
+    const profile = parseGoalProfile(context);
+    if (profile.relationalDataApp) {
+        const sqlSchema = findFileRecursive(appDir, (rel) => rel === "schema.sql" || rel.endsWith("/schema.sql")) ??
+            findFileRecursive(appDir, (rel) => rel.endsWith(".sql") && (rel.includes("schema") || rel.includes("init") || rel.includes("migration")), 10);
+        if (!sqlSchema) {
+            return {
+                ok: false,
+                command: "advanced-quality-check",
+                output: "Missing SQL schema file (expected schema.sql or migration .sql) for relational data app"
+            };
+        }
+        const schemaText = normalizeText(fs_1.default.readFileSync(path_1.default.join(appDir, schemaDoc), "utf-8"));
+        const readmeText = readme;
+        if (!/(postgres|postgresql|mysql|mariadb|sqlite)/.test(`${schemaText}\n${readmeText}`)) {
+            return {
+                ok: false,
+                command: "advanced-quality-check",
+                output: "Database technology not explicit in README/schemas (expected PostgreSQL/MySQL/MariaDB/SQLite)"
+            };
+        }
+    }
+    if (profile.javaReactFullstack) {
+        const hasBackendPom = fs_1.default.existsSync(path_1.default.join(appDir, "backend", "pom.xml"));
+        const hasFrontendPkg = fs_1.default.existsSync(path_1.default.join(appDir, "frontend", "package.json"));
+        if (!hasBackendPom || !hasFrontendPkg) {
+            return {
+                ok: false,
+                command: "advanced-quality-check",
+                output: "Expected Java+React fullstack structure: backend/pom.xml and frontend/package.json"
+            };
+        }
+        const frontendPkg = readPackageJson(path_1.default.join(appDir, "frontend"));
+        if (frontendPkg) {
+            const deps = { ...(frontendPkg.dependencies ?? {}), ...(frontendPkg.devDependencies ?? {}) };
+            if (typeof deps["react-query"] === "string") {
+                return {
+                    ok: false,
+                    command: "advanced-quality-check",
+                    output: "Outdated frontend dependency detected: react-query. Use @tanstack/react-query."
+                };
+            }
+            const requiredFrontendDeps = ["react-router-dom", "@tanstack/react-query"];
+            const missingFrontendDeps = requiredFrontendDeps.filter((dep) => typeof deps[dep] !== "string");
+            if (missingFrontendDeps.length > 0) {
+                return {
+                    ok: false,
+                    command: "advanced-quality-check",
+                    output: `Missing modern frontend dependencies: ${missingFrontendDeps.join(", ")}`
+                };
+            }
+        }
+        const backendRoot = path_1.default.join(appDir, "backend", "src", "main", "java");
+        if (!fs_1.default.existsSync(backendRoot)) {
+            return {
+                ok: false,
+                command: "advanced-quality-check",
+                output: "Missing backend/src/main/java for Java backend implementation"
+            };
+        }
+        const backendFiles = collectFilesRecursive(backendRoot, 12).filter((rel) => rel.toLowerCase().endsWith(".java"));
+        const hasDto = backendFiles.some((rel) => /\/dto\//i.test(`/${rel}`) || /dto\.java$/i.test(rel));
+        if (!hasDto) {
+            return {
+                ok: false,
+                command: "advanced-quality-check",
+                output: "Missing Java DTO layer (expected dto package and *Dto.java files)"
+            };
+        }
+        const hasRecord = backendFiles.some((rel) => /\brecord\b/.test(fs_1.default.readFileSync(path_1.default.join(backendRoot, rel), "utf-8")));
+        if (!hasRecord) {
+            return {
+                ok: false,
+                command: "advanced-quality-check",
+                output: "Missing Java record usage (expected at least one record for immutable transport/domain models)"
+            };
+        }
+        const serviceFiles = backendFiles.filter((rel) => /\/service\//i.test(`/${rel}`));
+        const repositoryFiles = backendFiles.filter((rel) => /\/repository\//i.test(`/${rel}`));
+        const hasServiceInterface = serviceFiles.some((rel) => /\binterface\b/.test(fs_1.default.readFileSync(path_1.default.join(backendRoot, rel), "utf-8")));
+        const hasRepositoryInterface = repositoryFiles.some((rel) => /\binterface\b/.test(fs_1.default.readFileSync(path_1.default.join(backendRoot, rel), "utf-8")));
+        if (!hasServiceInterface || !hasRepositoryInterface) {
+            return {
+                ok: false,
+                command: "advanced-quality-check",
+                output: "Missing service/repository interfaces in Java backend architecture"
+            };
+        }
+        const hasControllerAdvice = backendFiles.some((rel) => /@RestControllerAdvice\b/.test(fs_1.default.readFileSync(path_1.default.join(backendRoot, rel), "utf-8")));
+        if (!hasControllerAdvice) {
+            return {
+                ok: false,
+                command: "advanced-quality-check",
+                output: "Missing global exception handling (expected @RestControllerAdvice)"
+            };
+        }
+        const hasValidationUsage = backendFiles.some((rel) => {
+            const raw = fs_1.default.readFileSync(path_1.default.join(backendRoot, rel), "utf-8");
+            return /\b@(Valid|NotNull|NotBlank|Size|Email)\b/.test(raw) && /(jakarta|javax)\.validation/.test(raw);
+        });
+        if (!hasValidationUsage) {
+            return {
+                ok: false,
+                command: "advanced-quality-check",
+                output: "Missing bean validation usage (expected @Valid/@NotBlank with jakarta/javax.validation imports)"
+            };
+        }
+        const pomPath = path_1.default.join(appDir, "backend", "pom.xml");
+        const pomRaw = fs_1.default.existsSync(pomPath) ? fs_1.default.readFileSync(pomPath, "utf-8").toLowerCase() : "";
+        const requiredBackendDeps = [
+            "lombok",
+            "spring-boot-starter-validation",
+            "spring-boot-starter-actuator"
+        ];
+        const missingBackendDeps = requiredBackendDeps.filter((dep) => !pomRaw.includes(dep));
+        if (missingBackendDeps.length > 0) {
+            return {
+                ok: false,
+                command: "advanced-quality-check",
+                output: `Missing backend dependencies for production quality: ${missingBackendDeps.join(", ")}`
+            };
+        }
+        const hasMetricsConfig = (() => {
+            const metricsFile = fileExistsAny(path_1.default.join(appDir, "backend"), [
+                "src/main/resources/application.yml",
+                "src/main/resources/application.yaml",
+                "src/main/resources/application.properties"
+            ]);
+            if (!metricsFile) {
+                return false;
+            }
+            const text = normalizeText(fs_1.default.readFileSync(metricsFile, "utf-8"));
+            return /management\.endpoints|prometheus|actuator/.test(text);
+        })();
+        if (!hasMetricsConfig) {
+            return {
+                ok: false,
+                command: "advanced-quality-check",
+                output: "Missing backend telemetry config (expected actuator/prometheus management settings)"
+            };
+        }
+        const frontendRoot = path_1.default.join(appDir, "frontend", "src");
+        if (!fs_1.default.existsSync(frontendRoot)) {
+            return {
+                ok: false,
+                command: "advanced-quality-check",
+                output: "Missing frontend/src for React frontend implementation"
+            };
+        }
+        const frontendFiles = collectFilesRecursive(frontendRoot, 10);
+        const hasApiLayer = frontendFiles.some((rel) => /^api\//i.test(rel) || /\/api\//i.test(`/${rel}`));
+        const hasHooksLayer = frontendFiles.some((rel) => /^hooks\/use[A-Z].*\.(t|j)sx?$/i.test(rel) || /\/hooks\/use[A-Z]/.test(rel));
+        const hasComponentsLayer = frontendFiles.some((rel) => /^components\//i.test(rel) || /\/components\//i.test(`/${rel}`));
+        if (!hasApiLayer || !hasHooksLayer || !hasComponentsLayer) {
+            return {
+                ok: false,
+                command: "advanced-quality-check",
+                output: "Missing frontend layers (expected src/api, src/hooks/use*.ts(x), and src/components)"
+            };
+        }
+        const frontendTestCount = countJsTsTests(path_1.default.join(appDir, "frontend"), 10);
+        if (frontendTestCount < 3) {
+            return {
+                ok: false,
+                command: "advanced-quality-check",
+                output: `Expected at least 3 frontend tests for Java+React profile, found ${frontendTestCount}`
+            };
+        }
+        const frontendUsesStrictMode = (() => {
+            const mainCandidate = fileExistsAny(path_1.default.join(appDir, "frontend"), ["src/main.tsx", "src/main.jsx", "src/index.tsx", "src/index.jsx"]);
+            if (!mainCandidate) {
+                return false;
+            }
+            const raw = fs_1.default.readFileSync(mainCandidate, "utf-8");
+            return /StrictMode/.test(raw);
+        })();
+        if (!frontendUsesStrictMode) {
+            return {
+                ok: false,
+                command: "advanced-quality-check",
+                output: "Missing React StrictMode in frontend bootstrap"
+            };
+        }
+        const executionGuideExists = findFileRecursive(appDir, (rel) => rel === "execution-guide.md" || rel.endsWith("/execution-guide.md"), 8) ??
+            findFileRecursive(appDir, (rel) => rel.includes("runbook") && rel.endsWith(".md"), 8);
+        if (!executionGuideExists) {
+            return {
+                ok: false,
+                command: "advanced-quality-check",
+                output: "Missing execution guide/runbook markdown (expected execution-guide.md or runbook*.md)"
+            };
+        }
+        const architectureDocExists = findFileRecursive(appDir, (rel) => rel === "architecture.md" || rel.endsWith("/architecture.md"), 8) ??
+            findFileRecursive(appDir, (rel) => rel.includes("architecture") && rel.endsWith(".md"), 8);
+        if (!architectureDocExists) {
+            return {
+                ok: false,
+                command: "advanced-quality-check",
+                output: "Missing architecture documentation markdown (expected architecture.md)"
+            };
+        }
+    }
     const dummyLocalDoc = findFileRecursive(appDir, (rel) => rel.includes("dummylocal") && rel.endsWith(".md")) ??
         findFileRecursive(appDir, (rel) => rel.includes("dummy-local") && rel.endsWith(".md")) ??
         findFileRecursive(appDir, (rel) => rel.includes("dummy_local") && rel.endsWith(".md"));
@@ -329,7 +620,7 @@ function deriveRepoMetadata(projectName, appDir, context) {
     const goalSeed = context?.goalText ? tokenizeIntent(context.goalText).slice(0, 6).join("-") : "";
     const projectSeed = slugify(rawBase);
     const intentSeed = slugify(goalSeed);
-    const base = projectSeed || intentSeed || "sdd-project";
+    const base = intentSeed || projectSeed || "sdd-project";
     const cleaned = base.replace(/-app$/g, "");
     const repoName = `${cleaned}-app`.slice(0, 63).replace(/-+$/g, "");
     let description = context?.goalText?.trim()
@@ -463,6 +754,34 @@ function runAppLifecycle(projectRoot, projectName, context) {
     const build = runIfScript(appDir, "build");
     if (build)
         qualitySteps.push(build);
+    const backendDir = path_1.default.join(appDir, "backend");
+    if (fs_1.default.existsSync(path_1.default.join(backendDir, "pom.xml"))) {
+        if (hasCommand("mvn")) {
+            qualitySteps.push(run("mvn", ["-q", "test"], backendDir));
+        }
+        else {
+            qualitySteps.push({
+                ok: false,
+                command: "mvn -q test",
+                output: "Maven not available to validate Java backend"
+            });
+        }
+    }
+    const frontendDir = path_1.default.join(appDir, "frontend");
+    if (fs_1.default.existsSync(path_1.default.join(frontendDir, "package.json"))) {
+        if (packageNeedsInstall(frontendDir)) {
+            qualitySteps.push(run("npm", ["install"], frontendDir));
+        }
+        const feLint = runIfScript(frontendDir, "lint");
+        if (feLint)
+            qualitySteps.push(feLint);
+        const feTest = runIfScript(frontendDir, "test");
+        if (feTest)
+            qualitySteps.push(feTest);
+        const feBuild = runIfScript(frontendDir, "build");
+        if (feBuild)
+            qualitySteps.push(feBuild);
+    }
     qualitySteps.push(advancedQualityCheck(appDir, context));
     if (qualitySteps.length === 0) {
         qualitySteps.push(basicQualityCheck(appDir));

package/dist/commands/hello.js

@@ -418,7 +418,7 @@ async function runHello(input, runQuestions) {
                 if (!lifecycleDisabled && !lifecycle.qualityPassed) {
                     const appDir = path_1.default.join(projectRoot, "generated-app");
                     const parsedAttempts = Number.parseInt(process.env.SDD_AI_REPAIR_MAX_ATTEMPTS ?? "", 10);
-                    const maxRepairAttempts = Number.isFinite(parsedAttempts) && parsedAttempts > 0 ? parsedAttempts : 6;
+                    const maxRepairAttempts = Number.isFinite(parsedAttempts) && parsedAttempts > 0 ? parsedAttempts : 10;
                     printWhy("Quality gates failed. Attempting AI repair iterations.");
                     lifecycle.qualityDiagnostics.forEach((issue) => printWhy(`Quality issue: ${issue}`));
                     for (let attempt = 1; attempt <= maxRepairAttempts && !lifecycle.qualityPassed; attempt += 1) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sdd-cli",
-  "version": "0.1.25",
+  "version": "0.1.27",
   "description": "AI-orchestrated specification-driven delivery CLI that plans, validates, and ships production-ready software projects.",
   "keywords": [
     "cli",