sistema-multiagente-sdlc 1.2.0

package/scripts/validate-agent-persona-schema.mjs

@@ -0,0 +1,44 @@
+import fs from "node:fs";
+import path from "node:path";
+import { listFiles } from "../src/file-utils.js";
+
+const root = process.cwd();
+const files = listFiles(root).filter((file) => /^templates\/\.github\/agents\/.+\.agent\.md$/.test(file));
+const required = ["name", "model", "role", "phases", "inputs", "outputs"];
+const errors = [];
+
+function parseFrontmatter(content) {
+  const match = /^---\n([\s\S]*?)\n---/.exec(content);
+  if (!match) return null;
+  const out = {};
+  for (const line of match[1].split("\n")) {
+    const item = /^([A-Za-z0-9_-]+):\s*(.*)$/.exec(line.trim());
+    if (item) out[item[1]] = item[2];
+  }
+  return out;
+}
+
+for (const file of files) {
+  const content = fs.readFileSync(path.join(root, file), "utf8");
+  const frontmatter = parseFrontmatter(content);
+  if (!frontmatter) {
+    errors.push(`${file}: missing YAML frontmatter`);
+    continue;
+  }
+  for (const field of required) {
+    if (!frontmatter[field]) errors.push(`${file}: missing ${field}`);
+  }
+  for (const listField of ["phases", "inputs", "outputs"]) {
+    if (frontmatter[listField] && !/^\[[^\]]*\]$/.test(frontmatter[listField])) {
+      errors.push(`${file}: ${listField} must be an inline array`);
+    }
+  }
+}
+
+if (errors.length > 0) {
+  console.error("Agent persona schema validation: FAIL");
+  for (const error of errors) console.error(`- ${error}`);
+  process.exit(1);
+}
+
+console.log(`Agent persona schema validation: PASS (${files.length} personas)`);

package/scripts/validate-config-schema.mjs

@@ -0,0 +1,13 @@
+import { readFileSync } from "node:fs";
+import { validateConfigShape } from "../src/render.js";
+
+const config = JSON.parse(readFileSync(new URL("../sdlc.config.example.json", import.meta.url), "utf8"));
+const errors = validateConfigShape(config);
+
+if (errors.length > 0) {
+  console.error("Config schema validation: FAIL");
+  for (const error of errors) console.error(`- ${error}`);
+  process.exit(1);
+}
+
+console.log("Config schema validation: PASS");

package/scripts/validate-docs-links-exist.mjs

@@ -0,0 +1,51 @@
+import fs from "node:fs";
+import path from "node:path";
+import { listFiles } from "../src/file-utils.js";
+
+const root = process.cwd();
+const checkUrls = process.argv.includes("--check-urls");
+const mdFiles = listFiles(root).filter((file) => file.endsWith(".md") && !file.includes("node_modules/"));
+const errors = [];
+
+function stripCodeBlocks(content) {
+  return content.replace(/```[\s\S]*?```/g, "");
+}
+
+function shouldSkip(target) {
+  return (
+    target.startsWith("#") ||
+    target.startsWith("mailto:") ||
+    target.startsWith("http://") ||
+    target.startsWith("https://") ||
+    target.includes("{{") ||
+    target.includes("<") ||
+    target.includes(">")
+  );
+}
+
+for (const file of mdFiles) {
+  const content = stripCodeBlocks(fs.readFileSync(path.join(root, file), "utf8"));
+  const linkPattern = /(?<!!)\[[^\]]+\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g;
+  for (const match of content.matchAll(linkPattern)) {
+    const raw = match[1];
+    if (shouldSkip(raw)) {
+      if (!checkUrls && /^https?:\/\//.test(raw)) continue;
+      continue;
+    }
+    const clean = raw.split("#")[0];
+    if (!clean) continue;
+    const base = path.dirname(path.join(root, file));
+    const resolved = path.resolve(base, clean);
+    if (!resolved.startsWith(root) || !fs.existsSync(resolved)) {
+      errors.push(`${file}: broken link ${raw}`);
+    }
+  }
+}
+
+if (errors.length > 0) {
+  console.error("Docs links validation: FAIL");
+  for (const error of errors) console.error(`- ${error}`);
+  process.exit(1);
+}
+
+console.log(`Docs links validation: PASS (${mdFiles.length} markdown files)`);

package/scripts/validate-external-tools-policy.mjs

@@ -0,0 +1,35 @@
+import fs from "node:fs";
+import path from "node:path";
+import { listFiles } from "../src/file-utils.js";
+
+const root = process.cwd();
+const files = listFiles(root).filter((file) =>
+  /(^|\/)(templates\/scripts|scripts)\/.+\.(ps1|py|sh|mjs|js)$/.test(file)
+);
+
+const riskyPatterns = [
+  /\bnpx\s+(?:--yes\s+)?[\w@./-]+\s+(?:add|install)\b/i,
+  /\bpip\s+install\b/i,
+  /\bpython\s+-m\s+pip\s+install\b/i,
+  /\bRegister-ScheduledTask\b/i,
+  /\bInstall-Module\b/i
+];
+
+const errors = [];
+for (const file of files) {
+  const content = fs.readFileSync(path.join(root, file), "utf8");
+  const marked = /#\s*opt-in:external/i.test(content);
+  for (const pattern of riskyPatterns) {
+    if (pattern.test(content) && !marked) {
+      errors.push(`${file}: external side-effect command requires # opt-in:external marker (${pattern})`);
+    }
+  }
+}
+
+if (errors.length > 0) {
+  console.error("External tools policy validation: FAIL");
+  for (const error of errors) console.error(`- ${error}`);
+  process.exit(1);
+}
+
+console.log("External tools policy validation: PASS");

package/scripts/validate-governance-precedence.mjs

@@ -0,0 +1,32 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const root = process.cwd();
+const canonicalRoot = path.join(root, "templates", ".github", "skills");
+const mirrorRoots = [
+  path.join(root, "templates", ".claude", "skills"),
+  path.join(root, "templates", ".agents", "skills"),
+  path.join(root, "templates", ".windsurf", "skills")
+];
+
+const errors = [];
+for (const mirrorRoot of mirrorRoots) {
+  if (!fs.existsSync(mirrorRoot)) continue;
+  for (const entry of fs.readdirSync(mirrorRoot, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const mirrorSkill = path.join(mirrorRoot, entry.name, "SKILL.md");
+    if (!fs.existsSync(mirrorSkill)) continue;
+    const canonical = path.join(canonicalRoot, entry.name, "SKILL.md");
+    if (!fs.existsSync(canonical)) {
+      errors.push(`${path.relative(root, mirrorSkill)} exists without canonical .github/skills/${entry.name}/SKILL.md`);
+    }
+  }
+}
+
+if (errors.length > 0) {
+  console.error("Governance precedence validation: FAIL");
+  for (const error of errors) console.error(`- ${error}`);
+  process.exit(1);
+}
+
+console.log("Governance precedence validation: PASS");

package/scripts/validate-manifest-integrity.mjs

@@ -0,0 +1,49 @@
+import fs from "node:fs";
+import path from "node:path";
+import { sha256File } from "../src/file-utils.js";
+
+const targetArgIndex = process.argv.indexOf("--target");
+const target = targetArgIndex >= 0 ? path.resolve(process.argv[targetArgIndex + 1]) : process.cwd();
+const allowEmpty = process.argv.includes("--allow-empty");
+const manifests = [];
+
+function walk(current) {
+  if (!fs.existsSync(current)) return;
+  for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+    if (entry.name === "node_modules" || entry.name === ".git") continue;
+    const absolute = path.join(current, entry.name);
+    if (entry.isDirectory()) walk(absolute);
+    if (entry.isFile() && entry.name === "install-manifest.json" && path.basename(path.dirname(absolute)) === ".sdlc") {
+      manifests.push(absolute);
+    }
+  }
+}
+
+walk(target);
+
+const errors = [];
+for (const manifest of manifests) {
+  const checksumPath = path.join(path.dirname(manifest), "install-manifest.sha256");
+  if (!fs.existsSync(checksumPath)) {
+    errors.push(`${manifest}: falta install-manifest.sha256`);
+    continue;
+  }
+  const expected = fs.readFileSync(checksumPath, "utf8").trim();
+  const actual = sha256File(manifest);
+  if (expected !== actual) {
+    errors.push(`${manifest}: checksum invalido`);
+  }
+}
+
+if (errors.length > 0) {
+  console.error("Manifest integrity validation: FAIL");
+  for (const error of errors) console.error(`- ${error}`);
+  process.exit(1);
+}
+
+if (manifests.length === 0) {
+  console.warn("Manifest integrity validation: WARN — 0 manifest(s) encontrados (ningun repo instalado bajo --target)");
+  process.exit(allowEmpty ? 0 : 2);
+}
+
+console.log(`Manifest integrity validation: PASS (${manifests.length} manifest(s))`);

package/scripts/validate-models-schema.mjs

@@ -0,0 +1,42 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const root = process.cwd();
+const modelsPath = path.join(root, "templates", "scripts", "models.yaml");
+const content = fs.readFileSync(modelsPath, "utf8");
+const errors = [];
+
+function requirePattern(pattern, message) {
+  if (!pattern.test(content)) errors.push(message);
+}
+
+requirePattern(/^version:\s*1$/m, "version must be 1");
+requirePattern(/^updated:\s*"\d{4}-\d{2}-\d{2}"$/m, "updated must be quoted YYYY-MM-DD");
+requirePattern(/^roles:\s*$/m, "roles block is required");
+requirePattern(/^platforms:\s*$/m, "platforms block is required");
+requirePattern(/^fallbacks:\s*$/m, "fallbacks block is required");
+
+for (const role of ["orquestador", "planificador", "developer", "reviewer"]) {
+  requirePattern(new RegExp(`^  ${role}:\\s*$`, "m"), `role ${role} is required`);
+  requirePattern(new RegExp(`^  ${role}:\\s*\\n    primary:\\s*\\S+\\n    fallback:\\s*\\S+`, "m"), `role ${role} requires primary and fallback`);
+}
+
+for (const platform of ["claude_code", "codex", "copilot", "windsurf"]) {
+  requirePattern(new RegExp(`^  ${platform}:\\s*\\n    default:\\s*\\S+`, "m"), `platform ${platform} requires default`);
+}
+
+const allowedTopLevel = new Set(["version", "updated", "roles", "platforms", "fallbacks"]);
+for (const line of content.split("\n")) {
+  const match = /^([A-Za-z0-9_-]+):/.exec(line);
+  if (match && !allowedTopLevel.has(match[1])) {
+    errors.push(`unexpected top-level key: ${match[1]}`);
+  }
+}
+
+if (errors.length > 0) {
+  console.error("Models schema validation: FAIL");
+  for (const error of errors) console.error(`- ${error}`);
+  process.exit(1);
+}
+
+console.log("Models schema validation: PASS");

package/scripts/validate-mustache-references-exist.mjs

@@ -0,0 +1,44 @@
+import fs from "node:fs";
+import path from "node:path";
+import { defaultConfig } from "../src/render.js";
+import { listFiles } from "../src/file-utils.js";
+
+const root = process.cwd();
+const context = defaultConfig({
+  target: root,
+  mode: "greenfield",
+  projectName: "Example Project",
+  projectSlug: "example-project"
+});
+context.surfacesTable = "| `backend` | `apps/api` | `api-agent` |";
+context.surfacesList = "- `apps/api`";
+
+const files = listFiles(path.join(root, "templates")).filter((file) => {
+  const absolute = path.join(root, "templates", file);
+  return fs.statSync(absolute).isFile();
+});
+
+const errors = [];
+for (const file of files) {
+  const absolute = path.join(root, "templates", file);
+  const content = fs.readFileSync(absolute, "utf8");
+  for (const match of content.matchAll(/\{\{\s*([\w.]+)\s*\}\}/g)) {
+    const expr = match[1];
+    const value = expr.split(".").reduce((obj, key) => {
+      if (obj == null) return undefined;
+      if (/^\d+$/.test(key) && Array.isArray(obj)) return obj[Number(key)];
+      return obj[key];
+    }, context);
+    if (value == null) {
+      errors.push(`${path.relative(root, absolute)}: unresolved {{${expr}}}`);
+    }
+  }
+}
+
+if (errors.length > 0) {
+  console.error("Mustache references validation: FAIL");
+  for (const error of errors) console.error(`- ${error}`);
+  process.exit(1);
+}
+
+console.log("Mustache references validation: PASS");

package/scripts/validate-no-inline-managed-content.mjs

@@ -0,0 +1,92 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const targetFile = path.join(repoRoot, "src", "render.js");
+
+const MAX_LITERAL_LENGTH = 300;
+const MAX_LITERAL_NEWLINES = 5;
+
+const source = fs.readFileSync(targetFile, "utf8");
+
+function findTemplateLiterals(src) {
+  const literals = [];
+  let i = 0;
+  while (i < src.length) {
+    const ch = src[i];
+    if (ch === "/" && src[i + 1] === "/") {
+      while (i < src.length && src[i] !== "\n") i++;
+      continue;
+    }
+    if (ch === "/" && src[i + 1] === "*") {
+      i += 2;
+      while (i < src.length && !(src[i] === "*" && src[i + 1] === "/")) i++;
+      i += 2;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      const quote = ch;
+      i++;
+      while (i < src.length && src[i] !== quote) {
+        if (src[i] === "\\") i += 2;
+        else i++;
+      }
+      i++;
+      continue;
+    }
+    if (ch === "`") {
+      const start = i;
+      let lineStart = src.lastIndexOf("\n", start) + 1;
+      const startLine = src.slice(0, start).split("\n").length;
+      i++;
+      let newlines = 0;
+      while (i < src.length && src[i] !== "`") {
+        if (src[i] === "\\" && i + 1 < src.length) {
+          i += 2;
+          continue;
+        }
+        if (src[i] === "$" && src[i + 1] === "{") {
+          let depth = 1;
+          i += 2;
+          while (i < src.length && depth > 0) {
+            if (src[i] === "{") depth++;
+            else if (src[i] === "}") depth--;
+            if (src[i] === "\n") newlines++;
+            if (depth > 0) i++;
+          }
+          i++;
+          continue;
+        }
+        if (src[i] === "\n") newlines++;
+        i++;
+      }
+      const length = i - start - 1;
+      literals.push({ startLine, length, newlines });
+      i++;
+      continue;
+    }
+    i++;
+  }
+  return literals;
+}
+
+const literals = findTemplateLiterals(source);
+const violations = literals.filter(
+  (lit) => lit.length > MAX_LITERAL_LENGTH || lit.newlines > MAX_LITERAL_NEWLINES
+);
+
+if (violations.length > 0) {
+  console.error("No inline managed content validation: FAIL");
+  console.error(`src/render.js contiene template literals largos (potencial regresion al patron inline pre-Fase A).`);
+  console.error(`Limites: length<=${MAX_LITERAL_LENGTH}, newlines<=${MAX_LITERAL_NEWLINES}.`);
+  for (const violation of violations) {
+    console.error(`- line ${violation.startLine}: length=${violation.length}, newlines=${violation.newlines}`);
+  }
+  console.error("Mueva contenido a templates/ y referencielo via templates/manifest.yaml.");
+  process.exit(1);
+}
+
+console.log(
+  `No inline managed content validation: PASS (${literals.length} template literal(s), max length=${literals.reduce((m, l) => Math.max(m, l.length), 0)}, max newlines=${literals.reduce((m, l) => Math.max(m, l.newlines), 0)})`
+);

package/scripts/validate-no-personal-paths.mjs

@@ -0,0 +1,28 @@
+import fs from "node:fs";
+import path from "node:path";
+import { listFiles } from "../src/file-utils.js";
+
+const root = process.cwd();
+const patterns = [
+  /C:\\Users\\/i,
+  /\/Users\/[^/\s]+\/source\/repos/i
+];
+const errors = [];
+
+for (const file of listFiles(root)) {
+  const absolute = path.join(root, file);
+  const content = fs.readFileSync(absolute, "utf8");
+  for (const pattern of patterns) {
+    if (pattern.test(content)) {
+      errors.push(`${file} contiene ruta personal: ${pattern}`);
+    }
+  }
+}
+
+if (errors.length > 0) {
+  console.error("No personal paths validation: FAIL");
+  for (const error of errors) console.error(`- ${error}`);
+  process.exit(1);
+}
+
+console.log("No personal paths validation: PASS");

package/scripts/validate-no-placeholder-scripts.mjs

@@ -0,0 +1,33 @@
+import fs from "node:fs";
+import path from "node:path";
+import { listFiles } from "../src/file-utils.js";
+
+const root = process.cwd();
+const scriptFiles = listFiles(root).filter((file) =>
+  /(^|\/)(templates\/scripts|scripts)\/.+\.(ps1|py|sh|mjs|js)$/.test(file)
+);
+
+const patterns = [
+  /Write-Host\s+["']?pendiente/i,
+  /#\s*TODO:?.*implementar/i,
+  /throw\s+["']not implemented/i,
+  /pass\s*#\s*TODO/i
+];
+
+const errors = [];
+for (const file of scriptFiles) {
+  const content = fs.readFileSync(path.join(root, file), "utf8");
+  for (const pattern of patterns) {
+    if (pattern.test(content)) {
+      errors.push(`${file}: placeholder script marker matched ${pattern}`);
+    }
+  }
+}
+
+if (errors.length > 0) {
+  console.error("No placeholder scripts validation: FAIL");
+  for (const error of errors) console.error(`- ${error}`);
+  process.exit(1);
+}
+
+console.log(`No placeholder scripts validation: PASS (${scriptFiles.length} script files)`);

package/scripts/validate-openspec-consistency.mjs

@@ -0,0 +1,38 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const root = process.cwd();
+const specsRoot = path.join(root, "templates", "openspec", "specs");
+const errors = [];
+
+if (fs.existsSync(specsRoot)) {
+  for (const entry of fs.readdirSync(specsRoot, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const specPath = path.join(specsRoot, entry.name, "spec.md");
+    if (!fs.existsSync(specPath)) continue;
+    const content = fs.readFileSync(specPath, "utf8");
+    if (!/^#\s+/m.test(content)) errors.push(`${path.relative(root, specPath)}: missing title`);
+    if (!/## Requirements/m.test(content)) errors.push(`${path.relative(root, specPath)}: missing ## Requirements`);
+    if (!/### Requirement:/m.test(content)) errors.push(`${path.relative(root, specPath)}: missing Requirement blocks`);
+    if (!/#### Scenario:/m.test(content)) errors.push(`${path.relative(root, specPath)}: missing Scenario blocks`);
+  }
+}
+
+const changesRoot = path.join(root, "templates", "openspec", "changes");
+if (fs.existsSync(changesRoot)) {
+  for (const entry of fs.readdirSync(changesRoot, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const archivedMarker = path.join(changesRoot, entry.name, "archived.json");
+    if (fs.existsSync(archivedMarker)) {
+      errors.push(`archived change must live under archive/: ${path.relative(root, archivedMarker)}`);
+    }
+  }
+}
+
+if (errors.length > 0) {
+  console.error("OpenSpec consistency validation: FAIL");
+  for (const error of errors) console.error(`- ${error}`);
+  process.exit(1);
+}
+
+console.log("OpenSpec consistency validation: PASS");

package/scripts/validate-skill-manifest-consistency.mjs

@@ -0,0 +1,28 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const root = process.cwd();
+const skillsRoot = path.join(root, "templates", ".github", "skills");
+const manifestPath = path.join(root, "templates", "scripts", "agent-skills.manifest.json");
+const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+
+const actual = fs
+  .readdirSync(skillsRoot, { withFileTypes: true })
+  .filter((entry) => entry.isDirectory() && fs.existsSync(path.join(skillsRoot, entry.name, "SKILL.md")))
+  .map((entry) => entry.name)
+  .sort();
+
+const allowed = [...(manifest.repoGovernedSkills ?? [])].sort();
+const missing = actual.filter((skill) => !allowed.includes(skill));
+const stale = allowed.filter((skill) => !actual.includes(skill));
+const errors = [];
+if (missing.length > 0) errors.push(`missing from agent-skills.manifest.json: ${missing.join(", ")}`);
+if (stale.length > 0) errors.push(`manifest entries without .github skill: ${stale.join(", ")}`);
+
+if (errors.length > 0) {
+  console.error("Skill manifest consistency validation: FAIL");
+  for (const error of errors) console.error(`- ${error}`);
+  process.exit(1);
+}
+
+console.log(`Skill manifest consistency validation: PASS (${actual.length} skills)`);

package/scripts/validate-template-sanitization.mjs

@@ -0,0 +1,44 @@
+import fs from "node:fs";
+import path from "node:path";
+import { listFiles } from "../src/file-utils.js";
+
+const root = process.cwd();
+const allowed = [
+  /^docs\/extraction\//,
+  /^docs\/adr\//,
+  /^CHANGELOG\.md$/
+];
+const forbidden = [
+  /\bFacturacionDian\b/i,
+  /\bSamcol\b/i,
+  /\bFERRELECTRICOS\b/i,
+  /\bPasarelaDePago\b/i,
+  /\bpayment-core\b/i,
+  /\bPSE\b/
+];
+const errors = [];
+
+function isAllowed(file) {
+  return allowed.some((pattern) => pattern.test(file));
+}
+
+for (const file of listFiles(root)) {
+  if (isAllowed(file)) {
+    continue;
+  }
+  const absolute = path.join(root, file);
+  const content = fs.readFileSync(absolute, "utf8");
+  for (const pattern of forbidden) {
+    if (pattern.test(content)) {
+      errors.push(`${file} contiene termino no sanitizado: ${pattern}`);
+    }
+  }
+}
+
+if (errors.length > 0) {
+  console.error("Template sanitization validation: FAIL");
+  for (const error of errors) console.error(`- ${error}`);
+  process.exit(1);
+}
+
+console.log("Template sanitization validation: PASS");