@pukujan/create-modular-monolith 2.2.0 → 2.2.3

package/template/scripts/export-architecture-starter.mjs

@@ -0,0 +1,389 @@
+#!/usr/bin/env node
+/**
+ * Export architecture-only starter (no domain modules, no node_modules/dist/build).
+ *
+ * Usage:
+ *   npm run export:architecture-starter
+ *   npm run export:architecture-starter -- --to packages/create-modular-monolith/template
+ */
+import { cpSync, existsSync, mkdirSync, readFileSync, writeFileSync, rmSync, readdirSync } from "fs";
+import { join, dirname, resolve, isAbsolute } from "path";
+import { fileURLToPath } from "url";
+
+const repoRoot = join(dirname(fileURLToPath(import.meta.url)), "..");
+const templatesRoot = join(repoRoot, "export-templates");
+
+const EXCLUDE_DIRS = new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "coverage",
+  "packages",
+  "export",
+  "data",
+  "eval-bundles",
+  "case-exports",
+  "evals"
+]);
+
+const BACKEND_MODULES_KEEP = new Set(["_reference", "model-condenser"]);
+const FRONTEND_MODULES_KEEP = new Set(["_reference"]);
+
+const SCRIPTS_KEEP = new Set([
+  "new-module.mjs",
+  "sync-cli-template.mjs",
+  "export-architecture-starter.mjs",
+  "check-api-docs.mjs",
+  "lint-contracts.mjs",
+  "lint-repo-artifacts.mjs",
+  "condense-models.mjs",
+  "condense-prompts.mjs",
+  "condense-file-structure.mjs",
+  "condense-all.mjs",
+  "consolidated-output.mjs",
+  "write-pre-push-dev-log.mjs",
+  "verify-dev-log.mjs",
+  "import-to-file-exchange.mjs",
+  "resolve-import-stamp.mjs",
+  "export-consolidated-models.mjs",
+  "run-module-evals.mjs"
+]);
+
+const DOCS_KEEP_FILES = new Set([
+  "README.md",
+  "STARTER_PACK.md",
+  "PUBLISHING.md",
+  "DEVLOG_V2.md"
+]);
+
+function parseArgs(argv) {
+  let target = join(repoRoot, "export/architecture-starter");
+  for (let i = 0; i < argv.length; i += 1) {
+    if (argv[i] === "--to" && argv[i + 1]) {
+      const raw = argv[++i];
+      target = isAbsolute(raw) ? raw : resolve(process.cwd(), raw);
+    }
+  }
+  return { target };
+}
+
+function shouldExcludePath(sourcePath) {
+  const parts = sourcePath.split(/[/\\]/);
+  return parts.some((p) => EXCLUDE_DIRS.has(p));
+}
+
+function copyFiltered(src, dest, filterFn) {
+  cpSync(src, dest, {
+    recursive: true,
+    filter: (sourcePath) => {
+      if (shouldExcludePath(sourcePath)) return false;
+      return filterFn ? filterFn(sourcePath) : true;
+    }
+  });
+}
+
+function copyBackendModules(target) {
+  const srcRoot = join(repoRoot, "backend/src/modules");
+  const destRoot = join(target, "backend/src/modules");
+  mkdirSync(destRoot, { recursive: true });
+  writeFileSync(join(destRoot, ".gitkeep"), "");
+  for (const name of readdirSync(srcRoot)) {
+    if (!BACKEND_MODULES_KEEP.has(name)) continue;
+    copyFiltered(join(srcRoot, name), join(destRoot, name));
+    console.log(`  ✓ backend module ${name}`);
+  }
+}
+
+function copyScripts(target) {
+  const srcRoot = join(repoRoot, "scripts");
+  const destRoot = join(target, "scripts");
+  mkdirSync(destRoot, { recursive: true });
+  for (const name of readdirSync(srcRoot)) {
+    if (name === "lib") {
+      copyFiltered(join(srcRoot, "lib"), join(destRoot, "lib"));
+      console.log("  ✓ scripts/lib/");
+      continue;
+    }
+    if (name === "git-hooks") {
+      copyFiltered(join(srcRoot, "git-hooks"), join(destRoot, "git-hooks"));
+      console.log("  ✓ scripts/git-hooks/");
+      continue;
+    }
+    if (!SCRIPTS_KEEP.has(name)) continue;
+    cpSync(join(srcRoot, name), join(destRoot, name));
+    console.log(`  ✓ scripts/${name}`);
+  }
+}
+
+function copyDocs(target) {
+  const destDocs = join(target, "docs");
+  mkdirSync(destDocs, { recursive: true });
+  copyFiltered(join(repoRoot, "docs/architecture"), join(destDocs, "architecture"));
+  console.log("  ✓ docs/architecture/");
+  for (const name of DOCS_KEEP_FILES) {
+    const src = join(repoRoot, "docs", name);
+    if (existsSync(src)) {
+      cpSync(src, join(destDocs, name));
+      console.log(`  ✓ docs/${name}`);
+    }
+  }
+  cpSync(join(templatesRoot, "docs/API.starter.md"), join(destDocs, "API.md"));
+  mkdirSync(join(destDocs, "model-condenser"), { recursive: true });
+  cpSync(
+    join(repoRoot, "docs/model-condenser/API.md"),
+    join(destDocs, "model-condenser/API.md")
+  );
+  console.log("  ✓ docs/API.md (starter registry)");
+}
+
+function copyWorkLog(target) {
+  const dest = join(target, "work-log");
+  mkdirSync(dest, { recursive: true });
+  for (const name of ["README.md"]) {
+    cpSync(join(repoRoot, "work-log", name), join(dest, name));
+  }
+  writeFileSync(
+    join(dest, "INDEX.md"),
+    `# Work log — index\n\nSee [README.md](./README.md). Add handoffs, study-docs, and dev-log rows as you work.\n`
+  );
+  copyFiltered(join(repoRoot, "work-log/dev-logs"), join(dest, "dev-logs"), (p) => {
+    const base = p.split(/[/\\]/).pop() || "";
+    if (/^\d{3}_\d{4}-\d{2}-\d{2}_.*dev-log/.test(base)) return false;
+    if (p.includes("/human/") && p.endsWith(".md")) return !/\/human\/\d{3}_/.test(p);
+    if (p.includes("/agent/") && p.endsWith(".json")) return !/\/agent\/\d{3}_/.test(p);
+    return true;
+  });
+  mkdirSync(join(dest, "handoffs"), { recursive: true });
+  cpSync(join(repoRoot, "work-log/handoffs/README.md"), join(dest, "handoffs/README.md"));
+  mkdirSync(join(dest, "study-docs"), { recursive: true });
+  cpSync(join(repoRoot, "work-log/study-docs/README.md"), join(dest, "study-docs/README.md"));
+  console.log("  ✓ work-log/ (structure, no domain handoffs)");
+}
+
+function copyFileExchange(target) {
+  const dest = join(target, "file-exchange");
+  mkdirSync(join(dest, "imports"), { recursive: true });
+  mkdirSync(join(dest, "exports"), { recursive: true });
+  writeFileSync(join(dest, "imports/.gitkeep"), "");
+  writeFileSync(join(dest, "exports/.gitkeep"), "");
+  cpSync(join(repoRoot, "file-exchange/README.md"), join(dest, "README.md"));
+  console.log("  ✓ file-exchange/");
+}
+
+function copyCursor(target) {
+  copyFiltered(join(repoRoot, ".cursor"), join(target, ".cursor"));
+  console.log("  ✓ .cursor/");
+}
+
+function copySharedContracts(target) {
+  const sharedContracts = join(target, "backend/src/shared/contracts");
+  mkdirSync(sharedContracts, { recursive: true });
+  console.log("  ✓ backend/src/shared/ (via backend copy)");
+}
+
+function writeStarterRootFiles(target) {
+  cpSync(join(templatesRoot, "package.starter.json"), join(target, "package.json"));
+  cpSync(join(templatesRoot, "AGENTS.starter.md"), join(target, "AGENTS.md"));
+  cpSync(join(templatesRoot, "README.starter.md"), join(target, "README.md"));
+  cpSync(join(repoRoot, ".gitignore"), join(target, ".gitignore"));
+  cpSync(join(templatesRoot, "LICENSE.starter"), join(target, "LICENSE"));
+  cpSync(join(templatesRoot, "NOTICE.starter"), join(target, "NOTICE"));
+  mkdirSync(join(target, "models"), { recursive: true });
+  writeFileSync(join(target, "models/.gitkeep"), "");
+  console.log("  ✓ package.json, AGENTS.md, README, LICENSE, NOTICE, models/.gitkeep");
+}
+
+function patchStarterScripts(target) {
+  cpSync(
+    join(templatesRoot, "condense-prompts.starter.mjs"),
+    join(target, "scripts/condense-prompts.mjs")
+  );
+  cpSync(
+    join(templatesRoot, "modelCondenser.service.starter.js"),
+    join(
+      target,
+      "backend/src/modules/model-condenser/services/modelCondenser.service.js"
+    )
+  );
+  cpSync(
+    join(templatesRoot, "api-inventory.starter.mjs"),
+    join(target, "scripts/lib/api-inventory.mjs")
+  );
+  const repoTreePath = join(target, "scripts/lib/repo-tree.mjs");
+  let repoTree = readFileSync(repoTreePath, "utf8");
+  repoTree = repoTree.replace(
+    /export const TREE_IGNORE_PREFIXES = \[[\s\S]*?\];/,
+    'export const TREE_IGNORE_PREFIXES = ["data"];'
+  );
+  writeFileSync(repoTreePath, repoTree);
+
+  const fileStructurePath = join(target, "scripts/condense-file-structure.mjs");
+  let fileStructure = readFileSync(fileStructurePath, "utf8");
+  fileStructure = fileStructure.replace(
+    "and runtime batch/export paths.",
+    "and runtime data/ (if present)."
+  );
+  writeFileSync(fileStructurePath, fileStructure);
+  console.log("  ✓ starter patches (prompts, model-condenser, repo-tree)");
+}
+
+function writeManifest(target) {
+  const manifest = {
+    exportedAt: new Date().toISOString(),
+    sourceRepo: "legal-prmpt-eng",
+    description: "Architecture-only starter — no domain modules, no build artifacts",
+    included: {
+      backendModules: [...BACKEND_MODULES_KEEP],
+      frontendModules: [...FRONTEND_MODULES_KEEP],
+      docs: ["docs/architecture/**", "docs/API.md (starter)", "docs/model-condenser/API.md"],
+      scripts: [...SCRIPTS_KEEP, "scripts/lib/**", "scripts/git-hooks/**"],
+      other: [
+        "file-exchange/",
+        "work-log/ (structure)",
+        ".cursor/",
+        "backend/src/core",
+        "backend/src/shared",
+        "frontend/src/core",
+        "frontend/src/shared"
+      ]
+    },
+    excluded: {
+      dirs: [...EXCLUDE_DIRS],
+      backendModules: "case-filing-ai, court-rules, case-workflow, filing-*, human-review, task-docketing",
+      data: "runtime batches, golden fixtures, PDFs",
+      scripts: "ingest-golden-*, rerun-batch-evals, run-module-evals"
+    },
+    nextSteps: [
+      "Review export/ARCHITECTURE_EXPORT_README.md",
+      "npm install in backend/ and frontend/",
+      "npm run lint:contracts && npm run lint:architecture",
+      "node scripts/new-module.mjs my-feature --label \"My Feature\"",
+      "Copy into packages/create-modular-monolith/template or publish CLI"
+    ]
+  };
+  writeFileSync(join(target, "EXPORT_MANIFEST.json"), JSON.stringify(manifest, null, 2));
+}
+
+function writeExportReadme(target) {
+  const md = `# Architecture starter export
+
+Generated by \`npm run export:architecture-starter\`.
+
+## What this is
+
+A **clean modular-monolith boilerplate**: contracts, file-exchange, dev-logs, model-condenser, \`_reference\` module, lint scripts — **without** litigation/case-filing domain modules or runtime data.
+
+## What was excluded
+
+- Domain backend/frontend modules (case-filing-ai, court-rules, …)
+- \`node_modules\`, \`dist\`, \`build\`
+- \`data/\`, \`evals/golden\`, batch PDFs, import bundles
+- Legal-specific ingest/eval scripts
+
+See \`EXPORT_MANIFEST.json\` for the full list.
+
+## Update npm CLI template
+
+\`\`\`bash
+npm run export:architecture-starter -- --to ../create-modular-monolith/packages/template
+# or from this repo:
+npm run export:architecture-starter -- --to packages/create-modular-monolith/template
+cd packages/create-modular-monolith && npm publish --access public
+\`\`\`
+
+## Docs
+
+Start at [docs/architecture/CONTRACTS_OVERVIEW.md](docs/architecture/CONTRACTS_OVERVIEW.md).
+
+`;
+  writeFileSync(join(target, "ARCHITECTURE_EXPORT_README.md"), md);
+}
+
+function patchLintRepoArtifacts(target) {
+  const path = join(target, "scripts/lint-repo-artifacts.mjs");
+  let text = readFileSync(path, "utf8");
+  text = text.replace(
+    /const requiredPaths = \[[\s\S]*?\];/,
+    `const requiredPaths = [
+  "docs/architecture/CONTRACTS_OVERVIEW.md",
+  "docs/architecture/REPO_ARTIFACT_LAYOUT.md",
+  "docs/architecture/contracts/manifest.json",
+  "docs/architecture/contracts/changelog.jsonl",
+  "docs/architecture/contracts/fileExchange.contract.md",
+  "docs/architecture/contracts/consolidatedExports.contract.md",
+  "docs/architecture/contracts/prePushDevLog.contract.md",
+  "docs/architecture/contracts/apiDocumentationRegistry.contract.md",
+  "backend/src/shared/contracts/prePushDevLog.contract.js",
+  "backend/src/shared/contracts/consolidatedExports.contract.js",
+  "work-log/dev-logs/schemas/dev-log-agent.v1.schema.json",
+  "work-log/dev-logs/human",
+  "work-log/dev-logs/agent",
+  "file-exchange/README.md",
+  "file-exchange/imports",
+  "file-exchange/exports",
+  "docs/API.md",
+  "backend/src/modules/_reference/index.js",
+  "backend/src/modules/model-condenser/index.js"
+];`
+  );
+  writeFileSync(path, text);
+}
+
+function main() {
+  const { target } = parseArgs(process.argv.slice(2));
+  if (existsSync(target)) {
+    rmSync(target, { recursive: true, force: true });
+  }
+  mkdirSync(target, { recursive: true });
+
+  console.log(`Exporting architecture starter → ${target}\n`);
+
+  console.log("Backend core + shared:");
+  copyFiltered(join(repoRoot, "backend/src/core"), join(target, "backend/src/core"));
+  copyFiltered(join(repoRoot, "backend/src/shared"), join(target, "backend/src/shared"));
+  copyBackendModules(target);
+
+  console.log("\nFrontend:");
+  for (const f of ["package.json", ".env.example"]) {
+    const src = join(repoRoot, "backend", f);
+    if (existsSync(src)) cpSync(src, join(target, "backend", f));
+  }
+  copyFiltered(join(repoRoot, "backend/scripts"), join(target, "backend/scripts"));
+  mkdirSync(join(target, "backend/db/migrations"), { recursive: true });
+  writeFileSync(join(target, "backend/db/migrations/.gitkeep"), "");
+  console.log("  ✓ backend/package.json, scripts/, db/");
+
+  console.log("\nFrontend shell:");
+  for (const f of ["package.json", "index.html", "vite.config.js", ".env.example"]) {
+    const src = join(repoRoot, "frontend", f);
+    if (existsSync(src)) cpSync(src, join(target, "frontend", f));
+  }
+  copyFiltered(join(repoRoot, "frontend/src"), join(target, "frontend/src"), (p) => {
+    const parts = p.split(/[/\\]/);
+    const modIdx = parts.indexOf("modules");
+    if (modIdx >= 0 && parts[modIdx + 1]) {
+      return FRONTEND_MODULES_KEEP.has(parts[modIdx + 1]);
+    }
+    return true;
+  });
+  console.log("  ✓ frontend/");
+
+  console.log("\nDocs, scripts, exchange, work-log:");
+  copyDocs(target);
+  copyScripts(target);
+  copyFileExchange(target);
+  copyWorkLog(target);
+  copyCursor(target);
+
+  console.log("\nRoot:");
+  writeStarterRootFiles(target);
+  patchStarterScripts(target);
+  patchLintRepoArtifacts(target);
+  writeManifest(target);
+  writeExportReadme(target);
+
+  console.log(`\nDone. See ${target}/ARCHITECTURE_EXPORT_README.md`);
+}
+
+main();

package/template/scripts/lib/api-inventory.mjs

@@ -65,9 +65,6 @@ function classifyRoute(row) {
   return "active";
 }
 
-/**
- * @param {string} repoRoot
- */
 export async function collectApiInventory(repoRoot) {
   const masterApiPath = join(repoRoot, "docs/API.md");
   const masterText = existsSync(masterApiPath) ? readText(masterApiPath) : "";
@@ -84,63 +81,38 @@ export async function collectApiInventory(repoRoot) {
     });
   }
 
-  const pkg = JSON.parse(readText(join(repoRoot, "package.json")));
-
-  const versioned = {
-    pipeline: {
-      app: pkg.version ?? "2.0.0",
-      note: "Add pipelineVersions.contract.js in domain modules when you introduce batch workflows"
-    },
-    prompts: {
-      defaultEnv: "n/a",
-      envVar: "MASTER_PROMPT_VERSION",
-      allowed: [],
-      specs: {},
-      notes: ["Add promptVersions.js in your domain module when you introduce LLM workflows"]
-    },
-    storage: {},
-    app: { packageJson: pkg.version }
-  };
-
-  const deprecated = { http: http.deprecated, cli: [], prompts: [], notes: [] };
-  const exportDeprecated = join(repoRoot, "scripts/export-consolidated-models.mjs");
-  if (existsSync(exportDeprecated)) {
-    const t = readText(exportDeprecated);
-    if (/@deprecated/i.test(t)) {
-      deprecated.cli.push({
-        command: "scripts/export-consolidated-models.mjs",
-        replacement: "npm run condense-models or POST /api/model-condenser/condense"
-      });
-    }
-  }
-
   const cli = [
-    { command: "npm run test:ci", purpose: "All CI gates (lint + test + evals)" },
     { command: "npm run dev-log:pre-push", purpose: "Paired human + agent dev logs" },
-    { command: "npm run condense:all", purpose: "Snapshots → file-exchange/exports/" },
-    { command: "npm run import:file-exchange", purpose: "Inbound → file-exchange/imports/{stamp}/" },
-    { command: "npm run lint:contracts", purpose: "Verify contract manifest paths" },
+    {
+      command: "npm run condense:all",
+      purpose: "consolidated snapshots → file-exchange/exports/{stamp}_consolidated/"
+    },
+    { command: "npm run import:file-exchange", purpose: "Inbound bundle → file-exchange/imports/{stamp}/" },
     { command: "npm --prefix backend run condense-models", purpose: "Regenerate consolidated-models.json" }
   ];
 
   return {
     capturedAt: new Date().toISOString(),
-    sourceDocs: ["docs/API.md", "backend/src/modules/*/routes/"],
+    sourceDocs: ["docs/API.md"],
     http,
     moduleStatus: moduleIndex.map((m) => ({
       module: m.module,
       basePath: m.basePath,
       status: m.status
     })),
-    versioned,
-    deprecated,
+    versioned: {
+      pipeline: null,
+      prompts: null,
+      storage: null,
+      app: {
+        packageJson: readText(join(repoRoot, "package.json")).match(/"version":\s*"([^"]+)"/)?.[1]
+      }
+    },
+    deprecated: { http: http.deprecated, cli: [], prompts: [], notes: [] },
     cli
   };
 }
 
-/**
- * @param {Awaited<ReturnType<typeof collectApiInventory>>} apis
- */
 export function formatApisMarkdown(apis) {
   const lines = [
     "### HTTP — active",
@@ -160,23 +132,6 @@ export function formatApisMarkdown(apis) {
   } else {
     lines.push("_none_");
   }
-  lines.push("", "### HTTP — deprecated", "");
-  if (apis.http.deprecated.length) {
-    lines.push("| Method | Path | Module | Description |", "|--------|------|--------|-------------|");
-    for (const r of apis.http.deprecated) {
-      lines.push(`| ${r.method} | \`${r.path}\` | ${r.module} | ${r.description} |`);
-    }
-  } else {
-    lines.push("_none registered in docs/API.md_");
-  }
-  lines.push("", "### Versioned contracts (platform)", "", "```json");
-  lines.push(JSON.stringify(apis.versioned.pipeline, null, 2));
-  lines.push("```");
-  if (apis.deprecated.cli.length) {
-    lines.push("", "### Deprecated CLI", "");
-    for (const d of apis.deprecated.cli) {
-      lines.push(`- \`${d.command}\` → ${d.replacement}`);
-    }
-  }
+  lines.push("", "### HTTP — deprecated", "", "_none registered in docs/API.md_");
   return lines.join("\n");
 }

package/template/scripts/lib/repo-tree.mjs

@@ -5,9 +5,26 @@ import { join, extname } from "path";
 export const TREE_IGNORE_DIRS = ["node_modules", ".git", "dist", "build", ".DS_Store"];
 export const TREE_IGNORE_FILES = [".DS_Store"];
 
+/** Runtime / large paths (gitignored or handoff noise) — skip entire subtrees. */
+export const TREE_IGNORE_PREFIXES = ["data"];
+
 const EXCLUDE_DIRS = new Set(TREE_IGNORE_DIRS);
 const EXCLUDE_FILES = new Set(TREE_IGNORE_FILES);
 
+function normalizeRel(rel) {
+  return String(rel || "").replace(/\\/g, "/").replace(/^\.\//, "");
+}
+
+function isIgnoredPrefix(relPath, ignorePrefixes) {
+  const rel = normalizeRel(relPath);
+  if (!rel) return false;
+  for (const prefix of ignorePrefixes) {
+    const p = normalizeRel(prefix).replace(/\/$/, "");
+    if (rel === p || rel.startsWith(`${p}/`)) return true;
+  }
+  return false;
+}
+
 function renderTreeText(nodes, prefix = "") {
   const lines = [];
   for (let i = 0; i < nodes.length; i += 1) {
@@ -24,7 +41,7 @@ function renderTreeText(nodes, prefix = "") {
   return lines;
 }
 
-async function walkDir(absDir, relBase = "") {
+async function walkDir(absDir, relBase = "", ignorePrefixes = []) {
   const entries = await readdir(absDir, { withFileTypes: true });
   const dirs = [];
   const files = [];
@@ -32,6 +49,8 @@ async function walkDir(absDir, relBase = "") {
   for (const ent of entries) {
     if (ent.isDirectory()) {
       if (EXCLUDE_DIRS.has(ent.name)) continue;
+      const rel = relBase ? `${relBase}/${ent.name}` : ent.name;
+      if (isIgnoredPrefix(rel, ignorePrefixes)) continue;
       dirs.push(ent.name);
     } else if (ent.isFile()) {
       if (EXCLUDE_FILES.has(ent.name)) continue;
@@ -60,7 +79,7 @@ async function walkDir(absDir, relBase = "") {
 
   for (const name of dirs) {
     const rel = relBase ? `${relBase}/${name}` : name;
-    const sub = await walkDir(join(absDir, name), rel);
+    const sub = await walkDir(join(absDir, name), rel, ignorePrefixes);
     flatPaths.push(...sub.flatPaths);
     children.push({
       name,
@@ -105,15 +124,18 @@ function countStats(flatPaths, treeChildren) {
 
 /**
  * @param {string} repoRoot
+ * @param {{ ignorePrefixes?: string[] }} [options]
  * @returns {Promise<{ rootName: string, tree: object, treeText: string, stats: object, flatPaths: string[] }>}
  */
-export async function buildRepoTree(repoRoot) {
+export async function buildRepoTree(repoRoot, options = {}) {
+  const ignorePrefixes = options.ignorePrefixes ?? TREE_IGNORE_PREFIXES;
   const rootName = repoRoot.split("/").pop() || "repo";
-  const walked = await walkDir(repoRoot);
+  const walked = await walkDir(repoRoot, "", ignorePrefixes);
   const stats = countStats(walked.flatPaths, walked.children);
   const treeText = [rootName + "/", ...renderTreeText(walked.children)].join("\n");
   return {
     rootName,
+    excludePrefixes: ignorePrefixes,
     tree: {
       name: rootName,
       type: "directory",

package/template/scripts/sync-cli-template.mjs

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+/**
+ * Copies the v2 starter into packages/create-modular-monolith/template
+ * for publishing with the npm CLI.
+ */
+import { cpSync, existsSync, mkdirSync, rmSync } from "fs";
+import { join } from "path";
+
+const root = new URL("../", import.meta.url).pathname;
+const target = join(root, "packages/create-modular-monolith/template");
+
+const COPY_ROOTS = ["backend", "frontend", "docs", "scripts", "README.md", ".gitignore", "package.json"];
+
+const EXCLUDE_DIRS = new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "coverage",
+  "packages"
+]);
+
+if (existsSync(target)) {
+  rmSync(target, { recursive: true, force: true });
+}
+mkdirSync(target, { recursive: true });
+
+for (const item of COPY_ROOTS) {
+  const src = join(root, item);
+  if (!existsSync(src)) {
+    console.warn(`Skip missing: ${item}`);
+    continue;
+  }
+  const dest = join(target, item);
+  cpSync(src, dest, {
+    recursive: true,
+    filter: (sourcePath) => {
+      const parts = sourcePath.split(/[/\\]/);
+      return !parts.some((part) => EXCLUDE_DIRS.has(part));
+    }
+  });
+  console.log(`✓ ${item}`);
+}
+
+console.log(`\nTemplate synced to ${target}`);

package/template/scripts/write-pre-push-dev-log.mjs

@@ -168,6 +168,7 @@ async function main() {
     repositoryTree: {
       capturedAt: new Date().toISOString(),
       excludeDirs: TREE_IGNORE_DIRS,
+      excludePrefixes: tree.excludePrefixes,
       treeIgnoreFlag: 'tree -I "node_modules|.git|dist|build"',
       stats: tree.stats,
       treeText: tree.treeText,