@oss-ma/tpl 1.0.0

package/dist/commands/check.js

@@ -0,0 +1,83 @@
+import { Command } from "commander";
+import pc from "picocolors";
+import { loadStandardSchema, checkAgainstStandard } from "../engine/validators/standard.js";
+import { readTemplateLock } from "../engine/readLock.js";
+import { validateReactTs } from "../engine/validators/reactTs.js";
+import { loadPack } from "../engine/packs/loadPack.js";
+import { validatePackRules } from "../engine/packs/validatePackRules.js";
+function printHuman(result) {
+    if (result.ok) {
+        console.log(pc.green(`✅ OK — Standard v${result.schemaVersion}`));
+        console.log(`Project: ${result.projectPath}`);
+        return;
+    }
+    console.log(pc.red(`❌ FAILED — Standard v${result.schemaVersion}`));
+    console.log(`Project: ${result.projectPath}`);
+    console.log("");
+    for (const issue of result.issues) {
+        console.log(`${pc.red("•")} ${issue.message}${issue.path ? pc.gray(` (${issue.path})`) : ""}`);
+        if (issue.hint)
+            console.log(`  ${pc.gray("hint:")} ${issue.hint}`);
+    }
+    console.log("");
+    console.log(pc.yellow(`Total issues: ${result.issues.length}`));
+}
+export const checkCommand = new Command("check")
+    .option("--path <path>", "Project path", ".")
+    .option("--json", "JSON output")
+    .description("Check a project against the standard")
+    .action(async (opts) => {
+    try {
+        // 1) Standard
+        const { schema } = await loadStandardSchema();
+        const standardResult = await checkAgainstStandard(opts.path, schema);
+        // 2) Lock
+        const lock = await readTemplateLock(standardResult.projectPath);
+        // 3) Template-specific
+        let templateIssues = [];
+        if (lock?.template === "react-ts") {
+            templateIssues = await validateReactTs(standardResult.projectPath);
+        }
+        // 4) Packs
+        let packIssues = [];
+        if (lock?.packs?.length) {
+            for (const packName of lock.packs) {
+                const pack = await loadPack(packName);
+                const issues = await validatePackRules(pack, standardResult.projectPath);
+                // enforcement (strict vs advisory)
+                const level = pack.spec.enforcement?.level ?? "strict";
+                if (level === "advisory") {
+                    // On garde l’info mais on ne bloque pas (on tag en WARNING)
+                    packIssues.push(...issues.map((i) => ({
+                        ...i,
+                        code: `PACK_WARNING:${i.code}`,
+                        message: `${i.message} (advisory)`
+                    })));
+                }
+                else {
+                    packIssues.push(...issues);
+                }
+            }
+        }
+        // 5) Combine
+        const issues = [...standardResult.issues, ...templateIssues, ...packIssues];
+        // advisory warnings don't fail build
+        const blockingPackIssues = packIssues.filter((i) => !String(i.code).startsWith("PACK_WARNING:"));
+        const ok = standardResult.issues.length + templateIssues.length + blockingPackIssues.length === 0;
+        const result = { ...standardResult, issues, ok };
+        // 6) Output + exit
+        if (opts.json)
+            console.log(JSON.stringify(result, null, 2));
+        else
+            printHuman(result);
+        process.exit(result.ok ? 0 : 1);
+    }
+    catch (err) {
+        const msg = err?.message ?? String(err);
+        if (opts.json)
+            console.log(JSON.stringify({ ok: false, error: msg }, null, 2));
+        else
+            console.error(pc.red("❌ Error:"), msg);
+        process.exit(2);
+    }
+});

package/dist/commands/init.js

@@ -0,0 +1,96 @@
+import { Command } from "commander";
+import { initProject } from "../engine/initProject.js";
+function nowVars() {
+    const d = new Date();
+    const isoDate = d.toISOString();
+    const date = isoDate.slice(0, 10);
+    const year = String(d.getUTCFullYear());
+    return { isoDate, date, year };
+}
+export const initCommand = new Command("init")
+    .argument("<template>", "Template name (e.g. react-ts)")
+    .argument("<dir>", "Destination directory")
+    .option("--no-hooks", "Do not run post-generate hooks")
+    .option("--yes", "Use defaults, no prompts")
+    .option("--pack <name...>", "Apply one or more packs")
+    .option("--force", "Overwrite destination directory if not empty")
+    .description("Generate a new project from a template")
+    .action(async (templateName, dir, opts) => {
+    const res = await initProject({
+        templateName,
+        destDir: dir,
+        packs: opts.pack,
+        noHooks: !opts.hooks,
+        yes: !!opts.yes,
+        force: !!opts.force
+    });
+    console.log("\n✅ Project generated");
+    console.log(`- Path: ${res.destDir}`);
+});
+// import path from "node:path";
+// import fs from "fs-extra";
+// import { Command } from "commander";
+// import { loadTemplate } from "../engine/loadTemplate.js";
+// import { askQuestions } from "../engine/prompt.js";
+// import { copyAndRenderDir } from "../engine/copy.js";
+// import { writeTemplateLock } from "../engine/lock.js";
+// import { runHooks } from "../engine/hooks.js";
+// import { initProject } from "../engine/initProject.js";
+// function nowVars() {
+//   const d = new Date();
+//   const isoDate = d.toISOString();
+//   const date = isoDate.slice(0, 10);
+//   const year = String(d.getUTCFullYear());
+//   return { isoDate, date, year };
+// }
+// export const initCommand = new Command("init")
+//   .argument("<template>", "Template name (e.g. react-ts)")
+//   .argument("<dir>", "Destination directory")
+//   .option("--no-hooks", "Do not run post-generate hooks")
+//   .option("--yes", "Use defaults, no prompts")
+//   .description("Generate a new project from a template")
+//   .action(async (templateName: string, dir: string, opts: { hooks: boolean; yes?: boolean }) => {
+//     const { spec, filesDir } = await loadTemplate(templateName);
+//     const answers = await askQuestions(spec.questions, { yes: opts.yes });
+//     const pm = answers.packageManager || "npm";
+//     // system vars
+//     const sys = nowVars();
+//     const vars: Record<string, string> = {
+//       ...answers,
+//       ...sys,
+//       templateName: spec.name,
+//       templateVersion: spec.version
+//     };
+//     const destDir = path.resolve(process.cwd(), dir);
+//     if (await fs.pathExists(destDir)) {
+//       const content = await fs.readdir(destDir);
+//       if (content.length > 0) {
+//         throw new Error(`Destination not empty: ${destDir}`);
+//       }
+//     }
+//     await fs.ensureDir(destDir);
+//     // copy + render template files
+//     await copyAndRenderDir(filesDir, destDir, vars);
+//     // force lock (overwrites any template.lock from files/)
+//     await writeTemplateLock({
+//       destDir,
+//       template: spec.name,
+//       version: spec.version,
+//       options: answers,
+//       generatedAt: sys.isoDate
+//     });
+//     // hooks
+//     if (opts.hooks) {
+//       const cmds = spec.hooks?.postGenerate?.map((h) => {
+//         // allow {{var}} in hook command
+//         return h.run.replace(/\{\{\s*([a-zA-Z0-9_]+)\s*\}\}/g, (_, k) => vars[k] ?? `{{${k}}}`);
+//       });
+//       await runHooks(cmds, destDir);
+//     }
+//     console.log("\n✅ Project generated");
+//     console.log(`- Template: ${spec.name}@${spec.version}`);
+//     console.log(`- Path: ${destDir}`);
+//     console.log("\nNext:");
+//     console.log(`  cd ${dir}`);
+//     console.log(`  ${pm} run dev`);
+//   });

package/dist/engine/copy.js

@@ -0,0 +1,55 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { renderString } from "./render.js";
+const TEXT_EXT = new Set([
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".json",
+    ".md",
+    ".yml",
+    ".yaml",
+    ".html",
+    ".css",
+    ".scss",
+    ".txt",
+    ".env",
+    ".gitignore",
+    ".editorconfig",
+    ".gitattributes",
+    ".cjs",
+    ".mjs"
+]);
+function isTextFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (TEXT_EXT.has(ext))
+        return true;
+    // Special dotfiles with no extension
+    const base = path.basename(filePath);
+    if (base === "Dockerfile")
+        return true;
+    return false;
+}
+export async function copyAndRenderDir(srcDir, destDir, vars) {
+    await fs.ensureDir(destDir);
+    const entries = await fs.readdir(srcDir, { withFileTypes: true });
+    for (const e of entries) {
+        const srcPath = path.join(srcDir, e.name);
+        const destPath = path.join(destDir, e.name);
+        if (e.isDirectory()) {
+            await copyAndRenderDir(srcPath, destPath, vars);
+            continue;
+        }
+        if (e.isFile()) {
+            if (isTextFile(srcPath)) {
+                const raw = await fs.readFile(srcPath, "utf8");
+                const out = renderString(raw, vars);
+                await fs.outputFile(destPath, out, "utf8");
+            }
+            else {
+                await fs.copyFile(srcPath, destPath);
+            }
+        }
+    }
+}

package/dist/engine/hooks.js

@@ -0,0 +1,13 @@
+import { execa } from "execa";
+export async function runHooks(cmds, cwd) {
+    if (!cmds?.length)
+        return;
+    for (const cmd of cmds) {
+        // simple shell execution (cross-platform)
+        await execa(cmd, {
+            cwd,
+            shell: true,
+            stdio: "inherit"
+        });
+    }
+}

package/dist/engine/initProject.js

@@ -0,0 +1,68 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { loadTemplate } from "./loadTemplate.js";
+import { askQuestions } from "./prompt.js";
+import { copyAndRenderDir } from "./copy.js";
+import { writeTemplateLock } from "./lock.js";
+import { runHooks } from "./hooks.js";
+import { loadPack } from "./packs/loadPack.js";
+import { applyPackFiles } from "./packs/applyPackFiles.js";
+function nowVars() {
+    const d = new Date();
+    const isoDate = d.toISOString();
+    const date = isoDate.slice(0, 10);
+    const year = String(d.getUTCFullYear());
+    return { isoDate, date, year };
+}
+export async function initProject(params) {
+    const { spec, filesDir } = await loadTemplate(params.templateName);
+    const answers = await askQuestions(spec.questions, { yes: params.yes });
+    const sys = nowVars();
+    const vars = {
+        ...answers,
+        ...sys,
+        templateName: spec.name,
+        templateVersion: spec.version
+    };
+    const destDir = path.resolve(params.destDir);
+    // Destination handling
+    if (await fs.pathExists(destDir)) {
+        const content = await fs.readdir(destDir);
+        if (content.length > 0) {
+            if (params.force) {
+                await fs.emptyDir(destDir);
+            }
+            else {
+                throw new Error(`Destination not empty: ${destDir} (use --force)`);
+            }
+        }
+    }
+    await fs.ensureDir(destDir);
+    // 1) Copy + render template files
+    await copyAndRenderDir(filesDir, destDir, vars);
+    // 2) Apply packs (files + compatibility checks)
+    const appliedPacks = [];
+    for (const packName of params.packs ?? []) {
+        const pack = await loadPack(packName);
+        if (pack.spec.appliesTo?.templates && !pack.spec.appliesTo.templates.includes(spec.name)) {
+            throw new Error(`Pack "${packName}" not compatible with template "${spec.name}"`);
+        }
+        await applyPackFiles(pack, destDir, vars);
+        appliedPacks.push(pack.spec.name);
+    }
+    // 3) Write template.lock (includes packs)
+    await writeTemplateLock({
+        destDir,
+        template: spec.name,
+        version: spec.version,
+        options: answers,
+        packs: appliedPacks,
+        generatedAt: sys.isoDate
+    });
+    // 4) Hooks
+    if (!params.noHooks) {
+        const cmds = spec.hooks?.postGenerate?.map((h) => h.run.replace(/\{\{\s*([a-zA-Z0-9_]+)\s*\}\}/g, (_, k) => vars[k] ?? `{{${k}}}`));
+        await runHooks(cmds, destDir);
+    }
+    return { destDir };
+}

package/dist/engine/loadTemplate.js

@@ -0,0 +1,46 @@
+import path from "node:path";
+import fs from "fs-extra";
+import YAML from "yaml";
+import { findUp } from "../utils/findUp.js";
+export async function loadTemplate(templateName) {
+    const schemaPath = await findUp(process.cwd(), "standard.schema.json");
+    const repoRoot = schemaPath ? path.dirname(schemaPath) : null;
+    if (!repoRoot) {
+        throw new Error(`Cannot locate repo root (standard.schema.json not found upward from: ${process.cwd()})`);
+    }
+    const templateDir = path.join(repoRoot, "templates", templateName);
+    const templateYamlPath = path.join(templateDir, "template.yaml");
+    const filesDir = path.join(templateDir, "files");
+    if (!(await fs.pathExists(templateYamlPath))) {
+        throw new Error(`Template not found: ${templateYamlPath}`);
+    }
+    if (!(await fs.pathExists(filesDir))) {
+        throw new Error(`Template files folder not found: ${filesDir}`);
+    }
+    const raw = await fs.readFile(templateYamlPath, "utf8");
+    const spec = YAML.parse(raw);
+    if (!spec?.name || !spec?.version) {
+        throw new Error(`Invalid template.yaml: missing name/version (${templateYamlPath})`);
+    }
+    return { spec, templateDir, filesDir };
+}
+// export async function loadTemplate(templateName: string): Promise<LoadedTemplate> {
+//   // CLI is at: template-platform/cli
+//   // templates are at: template-platform/templates/<name>
+//   const repoRoot = path.resolve(process.cwd(), ".."); // assumes we run from cli/
+//   const templateDir = path.join(repoRoot, "templates", templateName);
+//   const templateYamlPath = path.join(templateDir, "template.yaml");
+//   const filesDir = path.join(templateDir, "files");
+//   if (!(await fs.pathExists(templateYamlPath))) {
+//     throw new Error(`Template not found: ${templateYamlPath}`);
+//   }
+//   if (!(await fs.pathExists(filesDir))) {
+//     throw new Error(`Template files folder not found: ${filesDir}`);
+//   }
+//   const raw = await fs.readFile(templateYamlPath, "utf8");
+//   const spec = YAML.parse(raw) as TemplateSpec;
+//   if (!spec?.name || !spec?.version) {
+//     throw new Error(`Invalid template.yaml: missing name/version (${templateYamlPath})`);
+//   }
+//   return { spec, templateDir, filesDir };
+// }

package/dist/engine/lock.js

@@ -0,0 +1,49 @@
+import path from "node:path";
+import fs from "fs-extra";
+export async function writeTemplateLock(params) {
+    const lockPath = path.join(params.destDir, "template.lock");
+    const data = {
+        template: params.template,
+        version: params.version,
+        options: params.options,
+        packs: params.packs ?? [],
+        generatedAt: params.generatedAt
+    };
+    await fs.writeFile(lockPath, JSON.stringify(data, null, 2) + "\n", "utf8");
+}
+// import path from "node:path";
+// import fs from "fs-extra";
+// export async function writeTemplateLock(params: {
+//   destDir: string;
+//   template: string;
+//   version: string;
+//   options: Record<string, string>;
+//   packs?: string[];
+//   generatedAt: string;
+// }) {
+//   const lockPath = path.join(params.destDir, "template.lock");
+//   const data = {
+//     template: params.template,
+//     version: params.version,
+//     options: params.options,
+//     packs: params.packs ?? [],
+//     generatedAt: params.generatedAt
+//   };
+//   await fs.writeFile(lockPath, JSON.stringify(data, null, 2) + "\n", "utf8");
+// }
+// // export async function writeTemplateLock(params: {
+// //   destDir: string;
+// //   template: string;
+// //   version: string;
+// //   options: Record<string, string>;
+// //   generatedAt: string;
+// // }): Promise<void> {
+// //   const lockPath = path.join(params.destDir, "template.lock");
+// //   const data = {
+// //     template: params.template,
+// //     version: params.version,
+// //     options: params.options,
+// //     generatedAt: params.generatedAt
+// //   };
+// //   await fs.writeFile(lockPath, JSON.stringify(data, null, 2) + "\n", "utf8");
+// // }

package/dist/engine/packs/applyPackFiles.js

@@ -0,0 +1,47 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { copyAndRenderDir } from "../copy.js";
+async function mergeDir(srcDir, destDir, packName) {
+    await fs.ensureDir(destDir);
+    const entries = await fs.readdir(srcDir, { withFileTypes: true });
+    for (const e of entries) {
+        const src = path.join(srcDir, e.name);
+        const dest = path.join(destDir, e.name);
+        if (e.isDirectory()) {
+            if (await fs.pathExists(dest)) {
+                const stat = await fs.stat(dest);
+                if (!stat.isDirectory()) {
+                    throw new Error(`Pack "${packName}" conflict: destination is a file: ${dest}`);
+                }
+            }
+            await mergeDir(src, dest, packName);
+            continue;
+        }
+        if (e.isFile()) {
+            if (await fs.pathExists(dest)) {
+                // Conflict only if the *same file path* already exists
+                throw new Error(`Pack "${packName}" conflict: file already exists: ${path.relative(destDir, dest)}`);
+            }
+            await fs.copyFile(src, dest);
+            continue;
+        }
+    }
+}
+export async function applyPackFiles(pack, projectDir, vars) {
+    if (!pack.filesDir)
+        return;
+    const tmpRoot = path.join(projectDir, ".pack-tmp");
+    const tmpDir = path.join(tmpRoot, pack.spec.name);
+    await fs.remove(tmpDir);
+    await fs.ensureDir(tmpDir);
+    try {
+        // Render pack files into tmpDir
+        await copyAndRenderDir(pack.filesDir, tmpDir, vars);
+        // Merge tmpDir into projectDir (directories are merged, files must not overwrite)
+        await mergeDir(tmpDir, projectDir, pack.spec.name);
+    }
+    finally {
+        // Always cleanup (even if we throw on conflict)
+        await fs.remove(tmpRoot);
+    }
+}

package/dist/engine/packs/loadPack.js

@@ -0,0 +1,27 @@
+import path from "node:path";
+import fs from "fs-extra";
+import YAML from "yaml";
+import { findUp } from "../../utils/findUp.js";
+export async function loadPack(packName) {
+    // findUp returns the FULL path to the "packs" directory
+    const packsDir = await findUp(process.cwd(), "packs");
+    if (!packsDir) {
+        throw new Error(`Cannot locate "packs" directory (searched upward from: ${process.cwd()})`);
+    }
+    // packsDir already ends with ".../packs"
+    const packDir = path.join(packsDir, packName);
+    const packYaml = path.join(packDir, "pack.yaml");
+    if (!(await fs.pathExists(packYaml))) {
+        throw new Error(`Pack not found: ${packName} (expected: ${packYaml})`);
+    }
+    const raw = await fs.readFile(packYaml, "utf8");
+    const spec = YAML.parse(raw);
+    if (!spec?.name || !spec?.version) {
+        throw new Error(`Invalid pack.yaml (missing name/version): ${packYaml}`);
+    }
+    const filesCandidate = path.join(packDir, "files");
+    const rulesCandidate = path.join(packDir, "rules");
+    const filesDir = (await fs.pathExists(filesCandidate)) ? filesCandidate : null;
+    const rulesDir = (await fs.pathExists(rulesCandidate)) ? rulesCandidate : null;
+    return { spec, packDir, filesDir, rulesDir };
+}

package/dist/engine/packs/validatePackRules.js

@@ -0,0 +1,141 @@
+import fs from "fs-extra";
+import path from "node:path";
+/**
+ * Validate rules defined by a pack against a project
+ */
+export async function validatePackRules(pack, projectDir) {
+    const issues = [];
+    if (!pack.rulesDir)
+        return issues;
+    const rulesFile = path.join(pack.rulesDir, "rules.json");
+    if (!(await fs.pathExists(rulesFile)))
+        return issues;
+    const rules = JSON.parse(await fs.readFile(rulesFile, "utf8"));
+    /**
+     * 1️⃣ Required files
+     */
+    if (Array.isArray(rules.requiredFiles)) {
+        for (const file of rules.requiredFiles) {
+            const target = path.join(projectDir, file);
+            if (!(await fs.pathExists(target))) {
+                issues.push({
+                    code: "PACK_MISSING_FILE",
+                    message: `[${pack.spec.name}] Missing required file: ${file}`,
+                    path: file
+                });
+            }
+        }
+    }
+    /**
+     * 2️⃣ Required npm scripts
+     */
+    if (Array.isArray(rules.requiredScripts)) {
+        const pkgPath = path.join(projectDir, "package.json");
+        if (await fs.pathExists(pkgPath)) {
+            const pkg = JSON.parse(await fs.readFile(pkgPath, "utf8"));
+            const scripts = pkg.scripts ?? {};
+            for (const script of rules.requiredScripts) {
+                if (!scripts[script]) {
+                    issues.push({
+                        code: "PACK_MISSING_SCRIPT",
+                        message: `[${pack.spec.name}] Missing required npm script: "${script}"`,
+                        path: "package.json"
+                    });
+                }
+            }
+        }
+    }
+    /**
+     * 3️⃣ Forbidden patterns (simple text scan)
+     * V1 intentionally simple → AST later if needed
+     */
+    if (Array.isArray(rules.forbiddenPatterns)) {
+        const srcDir = path.join(projectDir, "src");
+        if (await fs.pathExists(srcDir)) {
+            const files = await fs.readdir(srcDir, { recursive: true });
+            for (const file of files) {
+                if (typeof file !== "string" ||
+                    (!file.endsWith(".ts") && !file.endsWith(".tsx"))) {
+                    continue;
+                }
+                const absPath = path.join(srcDir, file);
+                const content = await fs.readFile(absPath, "utf8");
+                for (const pattern of rules.forbiddenPatterns) {
+                    if (content.includes(pattern)) {
+                        issues.push({
+                            code: "PACK_FORBIDDEN_PATTERN",
+                            message: `[${pack.spec.name}] Forbidden pattern "${pattern}" found`,
+                            path: file
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return issues;
+}
+// import fs from "fs-extra";
+// import path from "node:path";
+// import type { CheckIssue } from "../validators/standard.js";
+// import type { LoadedPack } from "./loadPack.js";
+// export async function validatePackRules(
+//   pack: LoadedPack,
+//   projectDir: string
+// ): Promise<CheckIssue[]> {
+//   const issues: CheckIssue[] = [];
+//   if (!pack.rulesDir) return issues;
+//   const rulesFile = path.join(pack.rulesDir, "rules.json");
+//   if (!(await fs.pathExists(rulesFile))) return issues;
+//   const rules = JSON.parse(await fs.readFile(rulesFile, "utf8"));
+//   // Required files
+//   if (rules.requiredFiles) {
+//     for (const f of rules.requiredFiles) {
+//       if (!(await fs.pathExists(path.join(projectDir, f)))) {
+//         issues.push({
+//           code: "PACK_MISSING_FILE",
+//           message: `[${pack.spec.name}] Missing required file: ${f}`,
+//           path: f
+//         });
+//       }
+//     }
+//   }
+//   // Required scripts
+//   if (rules.requiredScripts) {
+//     const pkgPath = path.join(projectDir, "package.json");
+//     if (await fs.pathExists(pkgPath)) {
+//       const pkg = JSON.parse(await fs.readFile(pkgPath, "utf8"));
+//       const scripts = pkg.scripts ?? {};
+//       for (const s of rules.requiredScripts) {
+//         if (!scripts[s]) {
+//           issues.push({
+//             code: "PACK_MISSING_SCRIPT",
+//             message: `[${pack.spec.name}] Missing required script: "${s}"`,
+//             path: "package.json"
+//           });
+//         }
+//       }
+//     }
+//   }
+//   // Forbidden patterns (simple scan)
+//   if (rules.forbiddenPatterns) {
+//     const srcDir = path.join(projectDir, "src");
+//     if (await fs.pathExists(srcDir)) {
+//       const files = await fs.readdir(srcDir, { recursive: true });
+//       for (const f of files) {
+//         // On ne scanne que les fichiers TS / TSX
+//         if (typeof f !== "string" || (!f.endsWith(".ts") && !f.endsWith(".tsx"))) continue;
+//         const content = await fs.readFile(path.join(srcDir, f), "utf8");
+//         for (const pattern of rules.forbiddenPatterns) {
+//           if (content.includes(pattern)) {
+//             issues.push({
+//               code: "PACK_FORBIDDEN_PATTERN",
+//               message: `[${pack.spec.name}] Forbidden pattern "${pattern}" found`,
+//               path: f
+//             });
+//           }
+//         }
+//       }
+//     }
+//   }
+//   return issues;
+// }

package/dist/engine/prompt.js

@@ -0,0 +1,66 @@
+import prompts from "prompts";
+export async function askQuestions(questions, opts = {}) {
+    if (!questions?.length)
+        return {};
+    // --yes : aucune interaction, on prend les defaults
+    if (opts.yes) {
+        const answers = {};
+        for (const q of questions)
+            answers[q.name] = String(q.default ?? "");
+        return answers;
+    }
+    const defs = questions.map((q) => {
+        const base = {
+            name: q.name,
+            message: q.message,
+            initial: q.default
+        };
+        if (q.choices?.length) {
+            return { type: "select", ...base, choices: q.choices.map((c) => ({ title: c, value: c })) };
+        }
+        return { type: "text", ...base };
+    });
+    // Sur certains terminaux Windows, prompts peut déclencher onCancel inopinément.
+    // Stratégie: si cancel -> fallback sur defaults au lieu de crash.
+    const res = (await prompts(defs, {
+        onCancel: () => true
+    }));
+    const out = {};
+    for (const q of questions) {
+        const v = res[q.name];
+        out[q.name] = v !== undefined && v !== null && String(v).length > 0 ? String(v) : String(q.default ?? "");
+    }
+    return out;
+}
+// import prompts from "prompts";
+// import type { TemplateQuestion } from "./loadTemplate.js";
+// export async function askQuestions(
+//   questions: TemplateQuestion[] | undefined,
+//   opts: { yes?: boolean } = {}
+// ): Promise<Record<string, string>> {
+//   if (!questions?.length) return {};
+//   if (opts.yes) {
+//     const answers: Record<string, string> = {};
+//     for (const q of questions) {
+//       answers[q.name] = String(q.default ?? "");
+//     }
+//     return answers;
+//   }
+//   const defs = questions.map((q) => {
+//     const base: any = {
+//       name: q.name,
+//       message: q.message,
+//       initial: q.default
+//     };
+//     if (q.choices?.length) {
+//       return { type: "select", ...base, choices: q.choices.map((c) => ({ title: c, value: c })) };
+//     }
+//     return { type: "text", ...base };
+//   });
+//   const res = await prompts(defs, {
+//     onCancel: () => {
+//       throw new Error("Cancelled by user.");
+//     }
+//   });
+//   return res as Record<string, string>;
+// }

package/dist/engine/readLock.js

@@ -0,0 +1,9 @@
+import path from "node:path";
+import fs from "fs-extra";
+export async function readTemplateLock(projectPath) {
+    const p = path.join(projectPath, "template.lock");
+    if (!(await fs.pathExists(p)))
+        return null;
+    const raw = await fs.readFile(p, "utf8");
+    return JSON.parse(raw);
+}

package/dist/engine/render.js

@@ -0,0 +1,6 @@
+export function renderString(input, vars) {
+    return input.replace(/\{\{\s*([a-zA-Z0-9_]+)\s*\}\}/g, (_, key) => {
+        const v = vars[key];
+        return v !== undefined ? String(v) : `{{${key}}}`; // keep unresolved visible
+    });
+}

package/dist/engine/validators/reactTs.js

@@ -0,0 +1,44 @@
+import path from "node:path";
+import fs from "fs-extra";
+async function readJson(p) {
+    const raw = await fs.readFile(p, "utf8");
+    return JSON.parse(raw);
+}
+export async function validateReactTs(projectPath) {
+    const issues = [];
+    // package.json scripts
+    const pkgPath = path.join(projectPath, "package.json");
+    if (!(await fs.pathExists(pkgPath))) {
+        issues.push({ code: "MISSING_FILE", message: "Missing package.json", path: "package.json" });
+        return issues;
+    }
+    const pkg = await readJson(pkgPath);
+    const scripts = pkg?.scripts ?? {};
+    const requiredScripts = ["lint", "format", "test", "build", "typecheck"];
+    for (const s of requiredScripts) {
+        if (!scripts[s]) {
+            issues.push({
+                code: "MISSING_SCRIPT",
+                message: `Missing npm script: "${s}"`,
+                path: "package.json",
+                hint: `Add it under scripts: "${s}": "..."`
+            });
+        }
+    }
+    // Gold Secure files
+    const secureFiles = [
+        ".github/dependabot.yml",
+        ".github/workflows/codeql.yml"
+    ];
+    for (const f of secureFiles) {
+        const p = path.join(projectPath, f);
+        if (!(await fs.pathExists(p))) {
+            issues.push({
+                code: "MISSING_SECURE_FILE",
+                message: `Missing security file: ${f}`,
+                path: f
+            });
+        }
+    }
+    return issues;
+}

package/dist/engine/validators/standard.js

@@ -0,0 +1,127 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { findUp } from "../../utils/findUp.js";
+async function fileExists(p) {
+    try {
+        const stat = await fs.stat(p);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function dirExists(p) {
+    try {
+        const stat = await fs.stat(p);
+        return stat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function extractMarkdownHeadings(md) {
+    // Extract headings like: ## Overview
+    const lines = md.split(/\r?\n/);
+    const headings = [];
+    for (const line of lines) {
+        const m = line.match(/^\s{0,3}#{1,6}\s+(.+?)\s*$/);
+        if (m)
+            headings.push(m[1].trim());
+    }
+    return headings;
+}
+// export async function loadStandardSchema(): Promise<{ schema: StandardSchema; schemaPath: string }> {
+//   // CLI lives in template-platform/cli
+//   // standard.schema.json lives in template-platform/standard.schema.json
+//   const repoRoot = path.resolve(process.cwd(), "..");
+//   const schemaPath = path.join(repoRoot, "standard.schema.json");
+//   if (!(await fileExists(schemaPath))) {
+//     throw new Error(`standard.schema.json not found at: ${schemaPath}`);
+//   }
+//   const raw = await fs.readFile(schemaPath, "utf8");
+//   const schema = JSON.parse(raw) as StandardSchema;
+//   if (!schema?.version || !Array.isArray(schema.requiredFiles) || !Array.isArray(schema.requiredDirs)) {
+//     throw new Error(`Invalid standard.schema.json: ${schemaPath}`);
+//   }
+//   return { schema, schemaPath };
+// }
+export async function loadStandardSchema() {
+    const schemaPath = await findUp(process.cwd(), "standard.schema.json");
+    if (!schemaPath) {
+        throw new Error(`standard.schema.json not found (searched upward from: ${process.cwd()})`);
+    }
+    const raw = await fs.readFile(schemaPath, "utf8");
+    const schema = JSON.parse(raw);
+    if (!schema?.version || !Array.isArray(schema.requiredFiles) || !Array.isArray(schema.requiredDirs)) {
+        throw new Error(`Invalid standard.schema.json: ${schemaPath}`);
+    }
+    return { schema, schemaPath };
+}
+export async function checkAgainstStandard(projectPath, schema) {
+    const issues = [];
+    const abs = path.resolve(projectPath);
+    // Required files
+    for (const rel of schema.requiredFiles ?? []) {
+        const p = path.join(abs, rel);
+        if (!(await fileExists(p))) {
+            issues.push({
+                code: "MISSING_FILE",
+                message: `Missing required file: ${rel}`,
+                path: rel
+            });
+        }
+    }
+    // Required dirs
+    for (const rel of schema.requiredDirs ?? []) {
+        const p = path.join(abs, rel);
+        if (!(await dirExists(p))) {
+            issues.push({
+                code: "MISSING_DIR",
+                message: `Missing required directory: ${rel}`,
+                path: rel
+            });
+        }
+    }
+    // Required ADR files
+    for (const rel of schema.requiredAdrFiles ?? []) {
+        const p = path.join(abs, rel);
+        if (!(await fileExists(p))) {
+            issues.push({
+                code: "MISSING_ADR",
+                message: `Missing ADR file: ${rel}`,
+                path: rel
+            });
+        }
+    }
+    // README headings
+    const readmePath = path.join(abs, "README.md");
+    if (await fileExists(readmePath)) {
+        const md = await fs.readFile(readmePath, "utf8");
+        const headings = extractMarkdownHeadings(md).map((h) => h.toLowerCase());
+        for (const required of schema.readmeRequiredHeadings ?? []) {
+            const ok = headings.includes(required.toLowerCase());
+            if (!ok) {
+                issues.push({
+                    code: "README_MISSING_HEADING",
+                    message: `README missing heading: "${required}"`,
+                    path: "README.md",
+                    hint: `Add a markdown heading like: "## ${required}"`
+                });
+            }
+        }
+    }
+    else {
+        // (already flagged as missing file, but add a hint)
+        issues.push({
+            code: "README_UNREADABLE",
+            message: "README.md could not be read",
+            path: "README.md"
+        });
+    }
+    return {
+        ok: issues.length === 0,
+        schemaVersion: schema.version,
+        projectPath: abs,
+        issues
+    };
+}

package/dist/engine/validators/template.js

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { initCommand } from "./commands/init.js";
+import { checkCommand } from "./commands/check.js";
+const program = new Command();
+program
+    .name("tpl")
+    .description("Template Platform CLI")
+    .version("0.1.0");
+program.addCommand(initCommand);
+program.addCommand(checkCommand);
+program.parse(process.argv);

package/dist/tests/smoke.test.js

@@ -0,0 +1,53 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import path from "node:path";
+import fs from "fs-extra";
+import { initProject } from "../engine/initProject.js";
+import { loadStandardSchema, checkAgainstStandard } from "../engine/validators/standard.js";
+import { readTemplateLock } from "../engine/readLock.js";
+import { validateReactTs } from "../engine/validators/reactTs.js";
+async function exists(p) {
+    return fs.pathExists(p);
+}
+test("smoke: init react-ts then check passes", async () => {
+    const tmpRoot = path.join(process.cwd(), ".tmp-tests");
+    const appDir = path.join(tmpRoot, "app-ok");
+    await fs.remove(tmpRoot);
+    await fs.ensureDir(tmpRoot);
+    await initProject({
+        templateName: "react-ts",
+        destDir: appDir,
+        noHooks: true,
+        yes: true
+    });
+    // required files quick check
+    assert.ok(await exists(path.join(appDir, "README.md")));
+    assert.ok(await exists(path.join(appDir, "template.lock")));
+    assert.ok(await exists(path.join(appDir, ".github", "workflows", "ci.yml")));
+    const { schema } = await loadStandardSchema();
+    const standard = await checkAgainstStandard(appDir, schema);
+    assert.equal(standard.ok, true, JSON.stringify(standard.issues, null, 2));
+    const lock = await readTemplateLock(appDir);
+    assert.ok(lock);
+    assert.equal(lock.template, "react-ts");
+    const extra = await validateReactTs(appDir);
+    assert.equal(extra.length, 0, JSON.stringify(extra, null, 2));
+});
+test("smoke: check fails when required file is missing", async () => {
+    const tmpRoot = path.join(process.cwd(), ".tmp-tests");
+    const appDir = path.join(tmpRoot, "app-ko");
+    await fs.remove(tmpRoot);
+    await fs.ensureDir(tmpRoot);
+    await initProject({
+        templateName: "react-ts",
+        destDir: appDir,
+        noHooks: true,
+        yes: true
+    });
+    // break it
+    await fs.remove(path.join(appDir, "README.md"));
+    const { schema } = await loadStandardSchema();
+    const standard = await checkAgainstStandard(appDir, schema);
+    assert.equal(standard.ok, false);
+    assert.ok(standard.issues.some((i) => i.code === "MISSING_FILE" && i.path === "README.md"));
+});

package/dist/utils/exec.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/findUp.js

@@ -0,0 +1,14 @@
+import path from "node:path";
+import fs from "fs-extra";
+export async function findUp(startDir, relPath) {
+    let cur = path.resolve(startDir);
+    while (true) {
+        const candidate = path.join(cur, relPath);
+        if (await fs.pathExists(candidate))
+            return candidate;
+        const parent = path.dirname(cur);
+        if (parent === cur)
+            return null; // reached filesystem root
+        cur = parent;
+    }
+}

package/dist/utils/fs.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/logger.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/path.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@oss-ma/tpl",
+  "version": "1.0.0",
+  "description": "Generate, enforce and maintain clean project architectures",
+  "type": "module",
+  "bin": {
+    "tpl": "./dist/index.js"
+  },
+  "files": ["dist"],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "tsc -p tsconfig.json",
+    "test:smoke": "node --test dist/tests/smoke.test.js"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "execa": "^9.3.0",
+    "fs-extra": "^11.2.0",
+    "picocolors": "^1.0.0",
+    "prompts": "^2.4.2",
+    "yaml": "^2.5.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^22.7.0",
+    "@types/prompts": "^2.4.9",
+    "tsx": "^4.16.2",
+    "typescript": "^5.5.4"
+  }
+}