create-project-arch 1.2.0 → 1.3.1

package/CHANGELOG.md

@@ -5,6 +5,18 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.3.0] - 2026-03-08
+
+### Added
+
+- Foundation, domain, architecture spec, concept-map, decision record, and gap-closure scaffolds.
+- Local validation hook scaffold (`scripts/validate.sh` and `.githooks/pre-commit`).
+
+### Changed
+
+- Validation-hook copy behavior now merges directories and preserves existing files while adding missing template files.
+- Template scaffolding flow expanded to include architecture governance docs by default.
+
 ## [1.1.0] - 2026-03-07
 
 ### Added
@@ -39,5 +51,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Template customization options
 - Force mode for non-empty directories
 
-[1.1.0]: https://github.com/project-arch/project-arch-system/compare/v1.0.0...v1.1.0
-[1.0.0]: https://github.com/project-arch/project-arch-system/releases/tag/v1.0.0
+[1.1.0]: https://github.com/MissTitanK3/project-arch-system/compare/v1.0.0...v1.1.0
+[1.0.0]: https://github.com/MissTitanK3/project-arch-system/releases/tag/v1.0.0
+[1.3.0]: https://github.com/MissTitanK3/project-arch-system/compare/v1.1.0...v1.3.0

package/README.md

@@ -80,7 +80,7 @@ When you run `create-project-arch`, it:
 
 ### Project Structure
 
-```
+```bash
 my-awesome-project/
 ├── apps/
 │   ├── arch/                    # Architecture UI (Next.js app)
@@ -107,12 +107,138 @@ my-awesome-project/
 │   │   └── phase-1/
 │   │       └── milestones/
 │   ├── decisions/
-│   └── docs/
+│   ├── docs/
+│   └── concept-map.json         # Concept-to-module traceability map
+├── architecture/
+│   ├── foundation/              # Milestone 1 prerequisite docs
+│   │   ├── prompt.md
+│   │   ├── project-overview.md
+│   │   ├── goals.md
+│   │   ├── user-journey.md
+│   │   └── scope.md
+│   ├── architecture/            # System architecture specs
+│   │   ├── SPEC_TEMPLATE.md
+│   │   └── example-system.md
+│   ├── decisions/               # Architecture decision records
+│       ├── DECISION_TEMPLATE.md
+│       └── example-decision.md
+│   └── reference/               # Reusable quality and closure references
+│       ├── GAP_CLOSURE_TEMPLATE.md
+│       └── example-gap-closure.md
+├── arch-domains/                # Domain boundaries and ownership
+│   ├── README.md
+│   ├── domains.json
+│   ├── DOMAIN_TEMPLATE.md
+│   ├── core.md
+│   ├── ui.md
+│   └── api.md
+├── scripts/
+│   └── validate.sh              # Local architecture validation hook
+├── .githooks/
+│   └── pre-commit               # Optional local pre-commit validation hook
 ├── package.json
 ├── turbo.json
 └── pnpm-workspace.yaml
 ```
 
+### Milestone 1 Prerequisites
+
+Scaffolded projects include these foundation docs by default under `architecture/foundation/`:
+
+- `prompt.md` (canonical source brief)
+- `project-overview.md`
+- `goals.md`
+- `user-journey.md`
+- `scope.md`
+
+Complete these files first before implementing milestone tasks.
+
+### Domain Spec Scaffold
+
+Scaffolded projects also include baseline domain specs under `arch-domains/`:
+
+- `domains.json` with starter domains (`core`, `ui`, `api`)
+- `DOMAIN_TEMPLATE.md` with required sections:
+  - Responsibilities
+  - Primary Data Ownership
+  - Interface Contracts
+  - Non-Goals
+  - Milestone Mapping
+- Starter specs: `core.md`, `ui.md`, and `api.md`
+
+### System Architecture Spec Scaffold
+
+Scaffolded projects include reusable architecture specs under `architecture/architecture/`:
+
+- `SPEC_TEMPLATE.md` with required sections:
+  - Purpose
+  - Scope (in-scope / out-of-scope)
+  - Key Definitions
+  - Design
+  - Data Model
+  - Owning Domain
+  - MVP Constraints
+- `example-system.md` showing a realistic completed reference
+
+### Concept-To-Module Traceability Scaffold
+
+Scaffolded projects include `arch-model/concept-map.json` with:
+
+- concept metadata (`id`, `name`, `description`)
+- owning domain assignment
+- module responsibilities
+- implementation surfaces (API/UI/component/code paths)
+- concept dependencies
+- domain-module mapping and implementation checklist placeholders
+
+### Decision Record Scaffold
+
+Scaffolded projects include architecture decision templates under `architecture/decisions/`:
+
+- `DECISION_TEMPLATE.md` with structured frontmatter (`id`, `title`, `slug`, `status`, timestamps, `relatedTasks`, `relatedDocs`, `supersedes`)
+- Required sections:
+  - Context
+  - Decision
+  - Rationale
+  - Alternatives Considered
+  - Affected Artifacts
+  - Implementation Status Checklist
+- `example-decision.md` demonstrating a completed decision record
+
+Use `pa decision new` for operational decision creation linked into roadmap decision indexes.
+
+### Milestone Gap-Closure Report Scaffold
+
+Scaffolded projects include closure report artifacts under `architecture/reference/`:
+
+- `GAP_CLOSURE_TEMPLATE.md` with sections for:
+  - Executive Summary
+  - Gap Categories And Resolutions
+  - Layer Synchronization Check
+  - Coverage Audit
+  - Remaining Gaps And Follow-On Items
+  - Template Improvement Feedback
+- `example-gap-closure.md` demonstrating a completed closure report
+
+Recommended workflow:
+
+1. Complete milestone tasks and decision updates.
+2. Run `pa check` and `pa report`.
+3. Record closure outcomes in milestone closure report.
+4. Track remaining gaps as follow-on tasks/decisions.
+
+### Local Validation Hook Scaffold
+
+Scaffolded projects include local validation automation assets:
+
+- `scripts/validate.sh` runs:
+  - `pnpm arch:check`
+  - `pnpm arch:report`
+- Optional local hook example:
+  - `.githooks/pre-commit`
+
+Use these hooks to keep architecture validation consistent in local workflows.
+
 ## Available Templates
 
 ### arch-ui (Default)
@@ -318,7 +444,7 @@ node dist/cli.js test-output --force
 
 Templates are stored in `templates/` directory:
 
-```
+```bash
 templates/
 ├── arch-ui/
 │   ├── package.json
@@ -472,19 +598,19 @@ npm run dev
 
 To add project-arch to an existing project:
 
-1. Install project-arch:
+### 1. Install project-arch
 
 ```bash
 pnpm add project-arch -w
 ```
 
-2. Initialize architecture:
+### 2. Initialize architecture
 
 ```bash
 pnpm exec pa init
 ```
 
-3. (Optional) Copy template files manually from this repository
+### 3. (Optional) Copy template files manually from this repository
 
 ## API Reference (Programmatic Usage)
 
@@ -530,9 +656,9 @@ MIT License - see [LICENSE](LICENSE) for details.
 
 ## Support
 
-- 📖 [Documentation](https://github.com/project-arch/project-arch-system#readme)
-- 🐛 [Issue Tracker](https://github.com/project-arch/project-arch-system/issues)
-- 💬 [Discussions](https://github.com/project-arch/project-arch-system/discussions)
+- 📖 [Documentation](https://github.com/MissTitanK3/project-arch-system#readme)
+- 🐛 [Issue Tracker](https://github.com/MissTitanK3/project-arch-system/issues)
+- 💬 [Discussions](https://github.com/MissTitanK3/project-arch-system/discussions)
 
 ## Acknowledgments
 
@@ -540,7 +666,7 @@ Built with:
 
 - [Commander.js](https://github.com/tj/commander.js) - CLI framework
 - [fs-extra](https://github.com/jprichardson/node-fs-extra) - File system utilities
-- [project-arch](https://github.com/project-arch/project-arch-system) - Architecture management
+- [project-arch](https://github.com/MissTitanK3/project-arch-system) - Architecture management
 
 ---
 

package/dist/cli.js

@@ -135,6 +135,150 @@ async function scaffoldArchitectureApps(targetDir) {
     await fs_extra_1.default.writeJSON(archUiPkgPath, nextArchUiPkg, { spaces: 2 });
     await fs_extra_1.default.appendFile(archUiPkgPath, "\n");
 }
+async function scaffoldFoundationDocs(targetDir) {
+    const templatesRoot = getTemplatesRoot();
+    const foundationTemplateRoot = path_1.default.join(templatesRoot, "foundation");
+    const foundationTargetRoot = path_1.default.join(targetDir, "architecture", "foundation");
+    if (!(await fs_extra_1.default.pathExists(foundationTemplateRoot))) {
+        throw new Error(`Missing foundation templates at ${foundationTemplateRoot}`);
+    }
+    await fs_extra_1.default.ensureDir(foundationTargetRoot);
+    const foundationEntries = await fs_extra_1.default.readdir(foundationTemplateRoot);
+    for (const entry of foundationEntries) {
+        const sourcePath = path_1.default.join(foundationTemplateRoot, entry);
+        const targetPath = path_1.default.join(foundationTargetRoot, entry);
+        if (await fs_extra_1.default.pathExists(targetPath)) {
+            continue;
+        }
+        await fs_extra_1.default.copy(sourcePath, targetPath, { overwrite: false });
+    }
+}
+async function scaffoldDomainSpecs(targetDir) {
+    const templatesRoot = getTemplatesRoot();
+    const domainsTemplateRoot = path_1.default.join(templatesRoot, "domains");
+    const domainsTargetRoot = path_1.default.join(targetDir, "arch-domains");
+    if (!(await fs_extra_1.default.pathExists(domainsTemplateRoot))) {
+        throw new Error(`Missing domain templates at ${domainsTemplateRoot}`);
+    }
+    await fs_extra_1.default.ensureDir(domainsTargetRoot);
+    const domainEntries = await fs_extra_1.default.readdir(domainsTemplateRoot);
+    for (const entry of domainEntries) {
+        const sourcePath = path_1.default.join(domainsTemplateRoot, entry);
+        const targetPath = path_1.default.join(domainsTargetRoot, entry);
+        if (entry === "DOMAIN_TEMPLATE.md" || entry === "README.md") {
+            await fs_extra_1.default.copy(sourcePath, targetPath, { overwrite: true });
+            continue;
+        }
+        if (entry === "domains.json") {
+            if (await fs_extra_1.default.pathExists(targetPath)) {
+                const existing = (await fs_extra_1.default.readJSON(targetPath));
+                if (Array.isArray(existing.domains) && existing.domains.length > 0) {
+                    continue;
+                }
+            }
+            await fs_extra_1.default.copy(sourcePath, targetPath, { overwrite: true });
+            continue;
+        }
+        if (await fs_extra_1.default.pathExists(targetPath)) {
+            continue;
+        }
+        await fs_extra_1.default.copy(sourcePath, targetPath, { overwrite: false });
+    }
+}
+async function scaffoldArchitectureSpecs(targetDir) {
+    const templatesRoot = getTemplatesRoot();
+    const architectureSpecsTemplateRoot = path_1.default.join(templatesRoot, "architecture-specs");
+    const architectureSpecsTargetRoot = path_1.default.join(targetDir, "architecture", "architecture");
+    if (!(await fs_extra_1.default.pathExists(architectureSpecsTemplateRoot))) {
+        throw new Error(`Missing architecture spec templates at ${architectureSpecsTemplateRoot}`);
+    }
+    await fs_extra_1.default.ensureDir(architectureSpecsTargetRoot);
+    const specEntries = await fs_extra_1.default.readdir(architectureSpecsTemplateRoot);
+    for (const entry of specEntries) {
+        const sourcePath = path_1.default.join(architectureSpecsTemplateRoot, entry);
+        const targetPath = path_1.default.join(architectureSpecsTargetRoot, entry);
+        if (await fs_extra_1.default.pathExists(targetPath)) {
+            continue;
+        }
+        await fs_extra_1.default.copy(sourcePath, targetPath, { overwrite: false });
+    }
+}
+async function scaffoldConceptMap(targetDir) {
+    const templatesRoot = getTemplatesRoot();
+    const conceptMapTemplatePath = path_1.default.join(templatesRoot, "concept-map", "concept-map.json");
+    const conceptMapTargetPath = path_1.default.join(targetDir, "arch-model", "concept-map.json");
+    if (!(await fs_extra_1.default.pathExists(conceptMapTemplatePath))) {
+        throw new Error(`Missing concept-map template at ${conceptMapTemplatePath}`);
+    }
+    await fs_extra_1.default.ensureDir(path_1.default.dirname(conceptMapTargetPath));
+    if (await fs_extra_1.default.pathExists(conceptMapTargetPath)) {
+        return;
+    }
+    await fs_extra_1.default.copy(conceptMapTemplatePath, conceptMapTargetPath, { overwrite: false });
+}
+async function scaffoldDecisionRecords(targetDir) {
+    const templatesRoot = getTemplatesRoot();
+    const decisionsTemplateRoot = path_1.default.join(templatesRoot, "decisions");
+    const decisionsTargetRoot = path_1.default.join(targetDir, "architecture", "decisions");
+    if (!(await fs_extra_1.default.pathExists(decisionsTemplateRoot))) {
+        throw new Error(`Missing decision templates at ${decisionsTemplateRoot}`);
+    }
+    await fs_extra_1.default.ensureDir(decisionsTargetRoot);
+    const entries = await fs_extra_1.default.readdir(decisionsTemplateRoot);
+    for (const entry of entries) {
+        const sourcePath = path_1.default.join(decisionsTemplateRoot, entry);
+        const targetPath = path_1.default.join(decisionsTargetRoot, entry);
+        if (await fs_extra_1.default.pathExists(targetPath)) {
+            continue;
+        }
+        await fs_extra_1.default.copy(sourcePath, targetPath, { overwrite: false });
+    }
+}
+async function scaffoldGapClosureTemplates(targetDir) {
+    const templatesRoot = getTemplatesRoot();
+    const gapClosureTemplateRoot = path_1.default.join(templatesRoot, "gap-closure");
+    const gapClosureTargetRoot = path_1.default.join(targetDir, "architecture", "reference");
+    if (!(await fs_extra_1.default.pathExists(gapClosureTemplateRoot))) {
+        throw new Error(`Missing gap-closure templates at ${gapClosureTemplateRoot}`);
+    }
+    await fs_extra_1.default.ensureDir(gapClosureTargetRoot);
+    const entries = await fs_extra_1.default.readdir(gapClosureTemplateRoot);
+    for (const entry of entries) {
+        const sourcePath = path_1.default.join(gapClosureTemplateRoot, entry);
+        const targetPath = path_1.default.join(gapClosureTargetRoot, entry);
+        if (await fs_extra_1.default.pathExists(targetPath)) {
+            continue;
+        }
+        await fs_extra_1.default.copy(sourcePath, targetPath, { overwrite: false });
+    }
+}
+async function scaffoldValidationHooks(targetDir) {
+    const templatesRoot = getTemplatesRoot();
+    const validationTemplateRoot = path_1.default.join(templatesRoot, "validation-hooks");
+    if (!(await fs_extra_1.default.pathExists(validationTemplateRoot))) {
+        throw new Error(`Missing validation hook templates at ${validationTemplateRoot}`);
+    }
+    const entries = await fs_extra_1.default.readdir(validationTemplateRoot);
+    for (const entry of entries) {
+        const sourcePath = path_1.default.join(validationTemplateRoot, entry);
+        const targetPath = path_1.default.join(targetDir, entry);
+        await copyMissingEntries(sourcePath, targetPath);
+    }
+}
+async function copyMissingEntries(sourcePath, targetPath) {
+    const sourceStats = await fs_extra_1.default.stat(sourcePath);
+    if (!sourceStats.isDirectory()) {
+        if (!(await fs_extra_1.default.pathExists(targetPath))) {
+            await fs_extra_1.default.copy(sourcePath, targetPath, { overwrite: false });
+        }
+        return;
+    }
+    await fs_extra_1.default.ensureDir(targetPath);
+    const children = await fs_extra_1.default.readdir(sourcePath);
+    for (const child of children) {
+        await copyMissingEntries(path_1.default.join(sourcePath, child), path_1.default.join(targetPath, child));
+    }
+}
 async function upsertArchModulesInMap(targetDir) {
     const modulesPath = path_1.default.join(targetDir, "arch-model", "modules.json");
     if (!(await fs_extra_1.default.pathExists(modulesPath))) {
@@ -213,6 +357,13 @@ async function main() {
             }
         }
         await runPaInit(targetDir, options);
+        await scaffoldFoundationDocs(targetDir);
+        await scaffoldDomainSpecs(targetDir);
+        await scaffoldArchitectureSpecs(targetDir);
+        await scaffoldConceptMap(targetDir);
+        await scaffoldDecisionRecords(targetDir);
+        await scaffoldGapClosureTemplates(targetDir);
+        await scaffoldValidationHooks(targetDir);
         await scaffoldArchitectureApps(targetDir);
         await upsertArchModulesInMap(targetDir);
         await wireProjectArchUsage(targetDir);

package/dist/cli.test.js

@@ -1,8 +1,199 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
 const vitest_1 = require("vitest");
+const currentDir = __dirname;
+const archUiEslintConfigPath = node_path_1.default.resolve(currentDir, "../templates/arch-ui/eslint.config.js");
+const foundationTemplateDir = node_path_1.default.resolve(currentDir, "../templates/foundation");
+const domainTemplateDir = node_path_1.default.resolve(currentDir, "../templates/domains");
+const architectureSpecTemplateDir = node_path_1.default.resolve(currentDir, "../templates/architecture-specs");
+const conceptMapTemplatePath = node_path_1.default.resolve(currentDir, "../templates/concept-map/concept-map.json");
+const decisionTemplateDir = node_path_1.default.resolve(currentDir, "../templates/decisions");
+const gapClosureTemplateDir = node_path_1.default.resolve(currentDir, "../templates/gap-closure");
+const validationHookTemplateDir = node_path_1.default.resolve(currentDir, "../templates/validation-hooks");
+const foundationTemplateExpectations = [
+    { fileName: "prompt.md", sectionHeader: "## Source Prompt" },
+    { fileName: "project-overview.md", sectionHeader: "## Problem Statement" },
+    { fileName: "goals.md", sectionHeader: "## Primary Goals" },
+    { fileName: "user-journey.md", sectionHeader: "## Journey Steps" },
+    { fileName: "scope.md", sectionHeader: "## In Scope" },
+];
+const domainTemplateExpectations = [
+    { fileName: "core.md", sectionHeader: "## Responsibilities" },
+    { fileName: "ui.md", sectionHeader: "## Responsibilities" },
+    { fileName: "api.md", sectionHeader: "## Responsibilities" },
+];
+const architectureSpecTemplateSections = [
+    "## Purpose",
+    "## Scope",
+    "## Key Definitions",
+    "## Design",
+    "## Data Model",
+    "## Owning Domain",
+    "## MVP Constraints",
+];
+const decisionTemplateSections = [
+    "## Context",
+    "## Decision",
+    "## Rationale",
+    "## Alternatives Considered",
+    "## Affected Artifacts",
+    "## Implementation Status Checklist",
+];
+const gapClosureTemplateSections = [
+    "## Executive Summary",
+    "## Gap Categories And Resolutions",
+    "## Layer Synchronization Check",
+    "## Coverage Audit",
+    "## Remaining Gaps And Follow-On Items",
+    "## Template Improvement Feedback",
+];
+function getImportedNextJsSymbol(source) {
+    const match = source.match(/import\s+\{\s*([A-Za-z_$][A-Za-z0-9_$]*)\s*\}\s+from\s+["']@repo\/eslint-config\/next-js["']/);
+    return match?.[1] ?? null;
+}
+function getDefaultExportedSymbol(source) {
+    const match = source.match(/export\s+default\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*;?/);
+    return match?.[1] ?? null;
+}
 (0, vitest_1.describe)("create-project-arch CLI", () => {
     (0, vitest_1.it)("runs test suite successfully", () => {
         (0, vitest_1.expect)(true).toBe(true);
     });
+    (0, vitest_1.it)("keeps arch-ui eslint template wired to @repo/eslint-config/next-js export", () => {
+        const archUiConfigSource = node_fs_1.default.readFileSync(archUiEslintConfigPath, "utf8");
+        const importedSymbol = getImportedNextJsSymbol(archUiConfigSource);
+        const defaultExportedSymbol = getDefaultExportedSymbol(archUiConfigSource);
+        (0, vitest_1.expect)(importedSymbol).toBeTruthy();
+        (0, vitest_1.expect)(defaultExportedSymbol).toBeTruthy();
+        (0, vitest_1.expect)(defaultExportedSymbol).toBe(importedSymbol);
+        (0, vitest_1.expect)(importedSymbol).toBe("nextJsConfig");
+    });
+    (0, vitest_1.it)("includes all foundation document templates with structured guidance", () => {
+        for (const expectation of foundationTemplateExpectations) {
+            const templatePath = node_path_1.default.join(foundationTemplateDir, expectation.fileName);
+            (0, vitest_1.expect)(node_fs_1.default.existsSync(templatePath)).toBe(true);
+            const templateSource = node_fs_1.default.readFileSync(templatePath, "utf8");
+            (0, vitest_1.expect)(templateSource).toContain(expectation.sectionHeader);
+            (0, vitest_1.expect)(templateSource).toContain("<!-- Guidance:");
+        }
+    });
+    (0, vitest_1.it)("includes domain spec templates with ownership and milestone mapping guidance", () => {
+        const domainsJsonPath = node_path_1.default.join(domainTemplateDir, "domains.json");
+        const domainTemplatePath = node_path_1.default.join(domainTemplateDir, "DOMAIN_TEMPLATE.md");
+        const domainReadmePath = node_path_1.default.join(domainTemplateDir, "README.md");
+        (0, vitest_1.expect)(node_fs_1.default.existsSync(domainReadmePath)).toBe(true);
+        (0, vitest_1.expect)(node_fs_1.default.readFileSync(domainReadmePath, "utf8")).toContain("domain boundaries");
+        (0, vitest_1.expect)(node_fs_1.default.existsSync(domainsJsonPath)).toBe(true);
+        const domainsJson = JSON.parse(node_fs_1.default.readFileSync(domainsJsonPath, "utf8"));
+        (0, vitest_1.expect)(Array.isArray(domainsJson.domains)).toBe(true);
+        (0, vitest_1.expect)(domainsJson.domains?.map((domain) => domain.name)).toEqual(["core", "ui", "api"]);
+        (0, vitest_1.expect)(node_fs_1.default.existsSync(domainTemplatePath)).toBe(true);
+        const domainTemplateSource = node_fs_1.default.readFileSync(domainTemplatePath, "utf8");
+        (0, vitest_1.expect)(domainTemplateSource).toContain("## Responsibilities");
+        (0, vitest_1.expect)(domainTemplateSource).toContain("## Primary Data Ownership");
+        (0, vitest_1.expect)(domainTemplateSource).toContain("## Interface Contracts");
+        (0, vitest_1.expect)(domainTemplateSource).toContain("## Non-Goals");
+        (0, vitest_1.expect)(domainTemplateSource).toContain("## Milestone Mapping");
+        for (const expectation of domainTemplateExpectations) {
+            const templatePath = node_path_1.default.join(domainTemplateDir, expectation.fileName);
+            (0, vitest_1.expect)(node_fs_1.default.existsSync(templatePath)).toBe(true);
+            const templateSource = node_fs_1.default.readFileSync(templatePath, "utf8");
+            (0, vitest_1.expect)(templateSource).toContain(expectation.sectionHeader);
+            (0, vitest_1.expect)(templateSource).toContain("## Milestone Mapping");
+        }
+    });
+    (0, vitest_1.it)("includes reusable architecture spec template and example", () => {
+        const specTemplatePath = node_path_1.default.join(architectureSpecTemplateDir, "SPEC_TEMPLATE.md");
+        const exampleSpecPath = node_path_1.default.join(architectureSpecTemplateDir, "example-system.md");
+        (0, vitest_1.expect)(node_fs_1.default.existsSync(specTemplatePath)).toBe(true);
+        const specTemplateSource = node_fs_1.default.readFileSync(specTemplatePath, "utf8");
+        for (const section of architectureSpecTemplateSections) {
+            (0, vitest_1.expect)(specTemplateSource).toContain(section);
+        }
+        (0, vitest_1.expect)(specTemplateSource).toContain("<!-- Guidance:");
+        (0, vitest_1.expect)(node_fs_1.default.existsSync(exampleSpecPath)).toBe(true);
+        const exampleSpecSource = node_fs_1.default.readFileSync(exampleSpecPath, "utf8");
+        (0, vitest_1.expect)(exampleSpecSource).toContain("# Example System Specification");
+        (0, vitest_1.expect)(exampleSpecSource).toContain("## Purpose");
+        (0, vitest_1.expect)(exampleSpecSource).toContain("## MVP Constraints");
+    });
+    (0, vitest_1.it)("includes concept-map template with traceability schema placeholders", () => {
+        (0, vitest_1.expect)(node_fs_1.default.existsSync(conceptMapTemplatePath)).toBe(true);
+        const conceptMap = JSON.parse(node_fs_1.default.readFileSync(conceptMapTemplatePath, "utf8"));
+        (0, vitest_1.expect)(conceptMap.schemaVersion).toBe("1.0");
+        (0, vitest_1.expect)(Array.isArray(conceptMap.concepts)).toBe(true);
+        (0, vitest_1.expect)((conceptMap.concepts ?? []).length).toBeGreaterThanOrEqual(2);
+        const firstConcept = conceptMap.concepts?.[0] ?? {};
+        (0, vitest_1.expect)(firstConcept).toHaveProperty("id");
+        (0, vitest_1.expect)(firstConcept).toHaveProperty("name");
+        (0, vitest_1.expect)(firstConcept).toHaveProperty("description");
+        (0, vitest_1.expect)(firstConcept).toHaveProperty("owningDomain");
+        (0, vitest_1.expect)(firstConcept).toHaveProperty("moduleResponsibilities");
+        (0, vitest_1.expect)(firstConcept).toHaveProperty("implementationSurfaces");
+        (0, vitest_1.expect)(firstConcept).toHaveProperty("dependencies");
+        (0, vitest_1.expect)(Array.isArray(conceptMap.domainModuleMapping)).toBe(true);
+        (0, vitest_1.expect)(Array.isArray(conceptMap.implementationChecklist)).toBe(true);
+    });
+    (0, vitest_1.it)("includes decision record template and example with structured frontmatter", () => {
+        const decisionTemplatePath = node_path_1.default.join(decisionTemplateDir, "DECISION_TEMPLATE.md");
+        const decisionExamplePath = node_path_1.default.join(decisionTemplateDir, "example-decision.md");
+        const decisionReadmePath = node_path_1.default.join(decisionTemplateDir, "README.md");
+        (0, vitest_1.expect)(node_fs_1.default.existsSync(decisionReadmePath)).toBe(true);
+        (0, vitest_1.expect)(node_fs_1.default.readFileSync(decisionReadmePath, "utf8")).toContain("pa decision new");
+        (0, vitest_1.expect)(node_fs_1.default.existsSync(decisionTemplatePath)).toBe(true);
+        const decisionTemplateSource = node_fs_1.default.readFileSync(decisionTemplatePath, "utf8");
+        (0, vitest_1.expect)(decisionTemplateSource).toContain("---");
+        (0, vitest_1.expect)(decisionTemplateSource).toContain("id:");
+        (0, vitest_1.expect)(decisionTemplateSource).toContain("title:");
+        (0, vitest_1.expect)(decisionTemplateSource).toContain("slug:");
+        (0, vitest_1.expect)(decisionTemplateSource).toContain("status:");
+        (0, vitest_1.expect)(decisionTemplateSource).toContain("createdAt:");
+        (0, vitest_1.expect)(decisionTemplateSource).toContain("updatedAt:");
+        (0, vitest_1.expect)(decisionTemplateSource).toContain("relatedTasks:");
+        (0, vitest_1.expect)(decisionTemplateSource).toContain("relatedDocs:");
+        for (const section of decisionTemplateSections) {
+            (0, vitest_1.expect)(decisionTemplateSource).toContain(section);
+        }
+        (0, vitest_1.expect)(node_fs_1.default.existsSync(decisionExamplePath)).toBe(true);
+        const decisionExampleSource = node_fs_1.default.readFileSync(decisionExamplePath, "utf8");
+        (0, vitest_1.expect)(decisionExampleSource).toContain('status: "accepted"');
+        (0, vitest_1.expect)(decisionExampleSource).toContain("## Decision");
+        (0, vitest_1.expect)(decisionExampleSource).toContain("## Alternatives Considered");
+    });
+    (0, vitest_1.it)("includes milestone gap-closure report template and example", () => {
+        const gapClosureTemplatePath = node_path_1.default.join(gapClosureTemplateDir, "GAP_CLOSURE_TEMPLATE.md");
+        const gapClosureExamplePath = node_path_1.default.join(gapClosureTemplateDir, "example-gap-closure.md");
+        const gapClosureReadmePath = node_path_1.default.join(gapClosureTemplateDir, "README.md");
+        (0, vitest_1.expect)(node_fs_1.default.existsSync(gapClosureReadmePath)).toBe(true);
+        (0, vitest_1.expect)(node_fs_1.default.readFileSync(gapClosureReadmePath, "utf8")).toContain("pa check");
+        (0, vitest_1.expect)(node_fs_1.default.existsSync(gapClosureTemplatePath)).toBe(true);
+        const gapClosureTemplateSource = node_fs_1.default.readFileSync(gapClosureTemplatePath, "utf8");
+        for (const section of gapClosureTemplateSections) {
+            (0, vitest_1.expect)(gapClosureTemplateSource).toContain(section);
+        }
+        (0, vitest_1.expect)(gapClosureTemplateSource).toContain("- [ ]");
+        (0, vitest_1.expect)(node_fs_1.default.existsSync(gapClosureExamplePath)).toBe(true);
+        const gapClosureExampleSource = node_fs_1.default.readFileSync(gapClosureExamplePath, "utf8");
+        (0, vitest_1.expect)(gapClosureExampleSource).toContain("# Milestone Gap-Closure Report - Example");
+        (0, vitest_1.expect)(gapClosureExampleSource).toContain("## Layer Synchronization Check");
+        (0, vitest_1.expect)(gapClosureExampleSource).toContain("- [x]");
+    });
+    (0, vitest_1.it)("includes local validation hook script and pre-commit example", () => {
+        const validateScriptPath = node_path_1.default.join(validationHookTemplateDir, "scripts", "validate.sh");
+        const preCommitPath = node_path_1.default.join(validationHookTemplateDir, ".githooks", "pre-commit");
+        const readmePath = node_path_1.default.join(validationHookTemplateDir, "README.md");
+        (0, vitest_1.expect)(node_fs_1.default.existsSync(validateScriptPath)).toBe(true);
+        const validateScriptSource = node_fs_1.default.readFileSync(validateScriptPath, "utf8");
+        (0, vitest_1.expect)(validateScriptSource).toContain("pnpm arch:check");
+        (0, vitest_1.expect)(validateScriptSource).toContain("pnpm arch:report");
+        (0, vitest_1.expect)(node_fs_1.default.existsSync(preCommitPath)).toBe(true);
+        (0, vitest_1.expect)(node_fs_1.default.readFileSync(preCommitPath, "utf8")).toContain("sh scripts/validate.sh");
+        (0, vitest_1.expect)(node_fs_1.default.existsSync(readmePath)).toBe(true);
+        (0, vitest_1.expect)(node_fs_1.default.readFileSync(readmePath, "utf8")).toContain("Task Verification Guidance");
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-project-arch",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "description": "Scaffold new projects with Project Arch templates including Next.js apps and component libraries",
   "keywords": [
     "create",
@@ -12,13 +12,13 @@
     "turborepo",
     "monorepo"
   ],
-  "homepage": "https://github.com/project-arch/project-arch-system#readme",
+  "homepage": "https://github.com/MissTitanK3/project-arch-system#readme",
   "bugs": {
-    "url": "https://github.com/project-arch/project-arch-system/issues"
+    "url": "https://github.com/MissTitanK3/project-arch-system/issues"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/project-arch/project-arch-system.git",
+    "url": "git+https://github.com/MissTitanK3/project-arch-system.git",
     "directory": "packages/create-project-arch"
   },
   "license": "MIT",
@@ -37,7 +37,7 @@
   "dependencies": {
     "commander": "^12.1.0",
     "fs-extra": "^11.3.0",
-    "project-arch": "^1.0.0"
+    "project-arch": "^1.3.0"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",

package/templates/arch-ui/eslint.config.js

@@ -1,2 +1,2 @@
-import { config } from '@repo/eslint-config/next-js';
-export default config;
+import { nextJsConfig } from '@repo/eslint-config/next-js';
+export default nextJsConfig;