create-project-arch 1.1.0 → 1.3.0

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,19 +1,43 @@
 {
   "name": "create-project-arch",
-  "version": "1.1.0",
-  "description": "Scaffold a project-arch monorepo",
+  "version": "1.3.0",
+  "description": "Scaffold new projects with Project Arch templates including Next.js apps and component libraries",
+  "keywords": [
+    "create",
+    "scaffold",
+    "template",
+    "project-arch",
+    "nextjs",
+    "react",
+    "turborepo",
+    "monorepo"
+  ],
+  "homepage": "https://github.com/project-arch/project-arch-system#readme",
+  "bugs": {
+    "url": "https://github.com/project-arch/project-arch-system/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/project-arch/project-arch-system.git",
+    "directory": "packages/create-project-arch"
+  },
+  "license": "MIT",
+  "author": "Project Arch Contributors",
   "bin": {
     "create-project-arch": "dist/cli.js"
   },
   "main": "dist/cli.js",
   "files": [
     "dist",
-    "templates"
+    "templates",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
   ],
   "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/.arch/edges/decision_to_domain.json

@@ -1,4 +1,3 @@
 {
   "edges": []
 }
-

package/templates/arch-ui/.arch/edges/milestone_to_task.json

@@ -1,4 +1,3 @@
 {
   "edges": []
 }
-

package/templates/arch-ui/.arch/edges/task_to_decision.json

@@ -1,4 +1,3 @@
 {
   "edges": []
 }
-

package/templates/arch-ui/.arch/edges/task_to_module.json

@@ -1,4 +1,3 @@
 {
   "edges": []
 }
-

package/templates/arch-ui/.arch/graph.json

@@ -14,4 +14,3 @@
     "milestone_to_task": 0
   }
 }
-

package/templates/arch-ui/.arch/nodes/decisions.json

@@ -1,4 +1,3 @@
 {
   "decisions": []
 }
-

package/templates/arch-ui/.arch/nodes/domains.json

@@ -1,4 +1,3 @@
 {
   "domains": []
 }
-

package/templates/arch-ui/.arch/nodes/milestones.json

@@ -1,4 +1,3 @@
 {
   "milestones": []
 }
-

package/templates/arch-ui/.arch/nodes/modules.json

@@ -1,4 +1,3 @@
 {
   "modules": []
 }
-

package/templates/arch-ui/.arch/nodes/tasks.json

@@ -1,4 +1,3 @@
 {
   "tasks": []
 }
-

package/templates/arch-ui/app/api/health/route.ts

@@ -9,12 +9,13 @@ export const runtime = "nodejs";
 export async function GET() {
   const root = getProjectRoot();
   process.env.PROJECT_ROOT = root;
-  const [checkResult, architectureMap] = await Promise.all([check.checkRun(), readArchitectureMap(root)]);
+  const [checkResult, architectureMap] = await Promise.all([
+    check.checkRun(),
+    readArchitectureMap(root),
+  ]);
   const { validation } = await buildValidatedGraphDataset(root, architectureMap);
 
-  const graphErrors = validation.errors.map(
-    (issue) => `[graph:${issue.ruleId}] ${issue.message}`,
-  );
+  const graphErrors = validation.errors.map((issue) => `[graph:${issue.ruleId}] ${issue.message}`);
   const graphWarnings = validation.warnings.map(
     (issue) => `[graph:${issue.ruleId}] ${issue.message}`,
   );

package/templates/arch-ui/app/api/node-files/route.ts

@@ -132,7 +132,12 @@ async function resolveFilesForNode(root: string, type: NodeType, id: string): Pr
     const [phase] = id.split("/");
     if (!phase || !isSafeSegment(phase)) return [];
     const phaseDir = path.join(root, "roadmap", "phases", phase);
-    return collectFiles(phaseDir, root, new Set(["milestones", "tasks", "node_modules", ".git"]), 2);
+    return collectFiles(
+      phaseDir,
+      root,
+      new Set(["milestones", "tasks", "node_modules", ".git"]),
+      2,
+    );
   }
 
   const [phase, milestone] = id.split("/");

package/templates/arch-ui/app/api/search/route.ts

@@ -53,4 +53,3 @@ export async function GET(request: NextRequest) {
     results: results.slice(0, 30),
   });
 }
-