@yinuo-ngm/mcp-server 0.1.1 → 0.1.3

package/lib/standard/frontend-standard.schema.d.ts

@@ -0,0 +1,196 @@
+import { z } from "zod";
+export declare const frontendStandardSchema: z.ZodObject<{
+    framework: z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        version?: string | undefined;
+    }, {
+        name: string;
+        version?: string | undefined;
+    }>;
+    uiLibrary: z.ZodObject<{
+        name: z.ZodString;
+        componentPrefix: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        componentPrefix?: string | undefined;
+    }, {
+        name: string;
+        componentPrefix?: string | undefined;
+    }>;
+    style: z.ZodObject<{
+        language: z.ZodString;
+        fileExtension: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        language: string;
+        fileExtension: string;
+    }, {
+        language: string;
+        fileExtension: string;
+    }>;
+    naming: z.ZodObject<{
+        branchPatterns: z.ZodArray<z.ZodString, "many">;
+        commitTypes: z.ZodArray<z.ZodString, "many">;
+        componentSuffixes: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        branchPatterns: string[];
+        commitTypes: string[];
+        componentSuffixes: string[];
+    }, {
+        branchPatterns: string[];
+        commitTypes: string[];
+        componentSuffixes: string[];
+    }>;
+    structure: z.ZodObject<{
+        pagesDir: z.ZodString;
+        componentsDir: z.ZodString;
+        servicesDir: z.ZodString;
+        modelsDir: z.ZodString;
+        maxComponentFileLines: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        pagesDir: string;
+        componentsDir: string;
+        servicesDir: string;
+        modelsDir: string;
+        maxComponentFileLines: number;
+    }, {
+        pagesDir: string;
+        componentsDir: string;
+        servicesDir: string;
+        modelsDir: string;
+        maxComponentFileLines: number;
+    }>;
+    git: z.ZodObject<{
+        branchPatterns: z.ZodArray<z.ZodString, "many">;
+        commitPattern: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        branchPatterns: string[];
+        commitPattern: string;
+    }, {
+        branchPatterns: string[];
+        commitPattern: string;
+    }>;
+    testing: z.ZodObject<{
+        requireServiceSpec: z.ZodBoolean;
+        requireUtilSpec: z.ZodBoolean;
+        suggestComponentSpec: z.ZodBoolean;
+    }, "strict", z.ZodTypeAny, {
+        requireServiceSpec: boolean;
+        requireUtilSpec: boolean;
+        suggestComponentSpec: boolean;
+    }, {
+        requireServiceSpec: boolean;
+        requireUtilSpec: boolean;
+        suggestComponentSpec: boolean;
+    }>;
+    review: z.ZodObject<{
+        requireChecklist: z.ZodBoolean;
+        riskKeywords: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        requireChecklist: boolean;
+        riskKeywords: string[];
+    }, {
+        requireChecklist: boolean;
+        riskKeywords: string[];
+    }>;
+}, "strict", z.ZodTypeAny, {
+    review: {
+        requireChecklist: boolean;
+        riskKeywords: string[];
+    };
+    framework: {
+        name: string;
+        version?: string | undefined;
+    };
+    uiLibrary: {
+        name: string;
+        componentPrefix?: string | undefined;
+    };
+    style: {
+        language: string;
+        fileExtension: string;
+    };
+    naming: {
+        branchPatterns: string[];
+        commitTypes: string[];
+        componentSuffixes: string[];
+    };
+    structure: {
+        pagesDir: string;
+        componentsDir: string;
+        servicesDir: string;
+        modelsDir: string;
+        maxComponentFileLines: number;
+    };
+    git: {
+        branchPatterns: string[];
+        commitPattern: string;
+    };
+    testing: {
+        requireServiceSpec: boolean;
+        requireUtilSpec: boolean;
+        suggestComponentSpec: boolean;
+    };
+}, {
+    review: {
+        requireChecklist: boolean;
+        riskKeywords: string[];
+    };
+    framework: {
+        name: string;
+        version?: string | undefined;
+    };
+    uiLibrary: {
+        name: string;
+        componentPrefix?: string | undefined;
+    };
+    style: {
+        language: string;
+        fileExtension: string;
+    };
+    naming: {
+        branchPatterns: string[];
+        commitTypes: string[];
+        componentSuffixes: string[];
+    };
+    structure: {
+        pagesDir: string;
+        componentsDir: string;
+        servicesDir: string;
+        modelsDir: string;
+        maxComponentFileLines: number;
+    };
+    git: {
+        branchPatterns: string[];
+        commitPattern: string;
+    };
+    testing: {
+        requireServiceSpec: boolean;
+        requireUtilSpec: boolean;
+        suggestComponentSpec: boolean;
+    };
+}>;
+export type FrontendStandard = z.infer<typeof frontendStandardSchema>;
+export type FindingSeverity = "info" | "warning" | "error";
+export type CheckStatus = "passed" | "warning" | "failed" | "blocked";
+export type StandardFinding = {
+    ruleId: string;
+    severity: FindingSeverity;
+    message: string;
+    file?: string;
+    line?: number;
+    suggestion?: string;
+};
+export type StandardCheckResult = {
+    status: CheckStatus;
+    findings: StandardFinding[];
+    summary: {
+        passed: number;
+        warnings: number;
+        errors: number;
+        nextSteps: string[];
+    };
+};
+export declare function summarizeFindings(findings: StandardFinding[]): StandardCheckResult;

package/lib/standard/frontend-standard.schema.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.frontendStandardSchema = void 0;
+exports.summarizeFindings = summarizeFindings;
+const zod_1 = require("zod");
+exports.frontendStandardSchema = zod_1.z.object({
+    framework: zod_1.z.object({
+        name: zod_1.z.string().min(1),
+        version: zod_1.z.string().optional(),
+    }).strict(),
+    uiLibrary: zod_1.z.object({
+        name: zod_1.z.string().min(1),
+        componentPrefix: zod_1.z.string().optional(),
+    }).strict(),
+    style: zod_1.z.object({
+        language: zod_1.z.string().min(1),
+        fileExtension: zod_1.z.string().min(1),
+    }).strict(),
+    naming: zod_1.z.object({
+        branchPatterns: zod_1.z.array(zod_1.z.string()).min(1),
+        commitTypes: zod_1.z.array(zod_1.z.string()).min(1),
+        componentSuffixes: zod_1.z.array(zod_1.z.string()).min(1),
+    }).strict(),
+    structure: zod_1.z.object({
+        pagesDir: zod_1.z.string().min(1),
+        componentsDir: zod_1.z.string().min(1),
+        servicesDir: zod_1.z.string().min(1),
+        modelsDir: zod_1.z.string().min(1),
+        maxComponentFileLines: zod_1.z.number().int().min(50).max(2000),
+    }).strict(),
+    git: zod_1.z.object({
+        branchPatterns: zod_1.z.array(zod_1.z.string()).min(1),
+        commitPattern: zod_1.z.string().min(1),
+    }).strict(),
+    testing: zod_1.z.object({
+        requireServiceSpec: zod_1.z.boolean(),
+        requireUtilSpec: zod_1.z.boolean(),
+        suggestComponentSpec: zod_1.z.boolean(),
+    }).strict(),
+    review: zod_1.z.object({
+        requireChecklist: zod_1.z.boolean(),
+        riskKeywords: zod_1.z.array(zod_1.z.string()),
+    }).strict(),
+}).strict();
+function summarizeFindings(findings) {
+    const errors = findings.filter((item) => item.severity === "error").length;
+    const warnings = findings.filter((item) => item.severity === "warning").length;
+    const status = errors > 0 ? "failed" : warnings > 0 ? "warning" : "passed";
+    return {
+        status,
+        findings,
+        summary: {
+            passed: findings.length === 0 ? 1 : 0,
+            warnings,
+            errors,
+            nextSteps: findings.length === 0
+                ? ["No action required."]
+                : findings.slice(0, 5).map((item) => item.suggestion ?? item.message),
+        },
+    };
+}

package/lib/standard/frontend-standard.service.d.ts

@@ -0,0 +1,79 @@
+import { type FrontendStandard, type StandardFinding } from "./frontend-standard.schema";
+import { type ResolvedProjectRoot } from "../filesystem/project-files";
+import { type SourceFile } from "./project-scan";
+export type LoadedFrontendStandard = {
+    source: "file" | "default";
+    path: string;
+    standard: FrontendStandard;
+};
+export declare function standardConfigPath(projectRoot: string): string;
+export declare function loadFrontendStandard(project: ResolvedProjectRoot): Promise<LoadedFrontendStandard>;
+export declare function initFrontendStandard(project: ResolvedProjectRoot, overwrite?: boolean): Promise<{
+    status: string;
+    path: string;
+    reason: string;
+    changedFiles?: undefined;
+    standard?: undefined;
+} | {
+    status: string;
+    path: string;
+    changedFiles: string[];
+    standard: {
+        review: {
+            requireChecklist: boolean;
+            riskKeywords: string[];
+        };
+        framework: {
+            name: string;
+            version?: string | undefined;
+        };
+        uiLibrary: {
+            name: string;
+            componentPrefix?: string | undefined;
+        };
+        style: {
+            language: string;
+            fileExtension: string;
+        };
+        naming: {
+            branchPatterns: string[];
+            commitTypes: string[];
+            componentSuffixes: string[];
+        };
+        structure: {
+            pagesDir: string;
+            componentsDir: string;
+            servicesDir: string;
+            modelsDir: string;
+            maxComponentFileLines: number;
+        };
+        git: {
+            branchPatterns: string[];
+            commitPattern: string;
+        };
+        testing: {
+            requireServiceSpec: boolean;
+            requireUtilSpec: boolean;
+            suggestComponentSpec: boolean;
+        };
+    };
+    reason?: undefined;
+}>;
+export declare function scanFrontendProject(projectRoot: string): Promise<SourceFile[]>;
+export declare function validateFrontendProject(project: ResolvedProjectRoot, standard: FrontendStandard): Promise<{
+    checks: {
+        structure: import("./frontend-standard.schema").StandardCheckResult;
+        componentNaming: import("./frontend-standard.schema").StandardCheckResult;
+        componentBoundary: import("./frontend-standard.schema").StandardCheckResult;
+        missingSpecs: import("./frontend-standard.schema").StandardCheckResult;
+        testNaming: import("./frontend-standard.schema").StandardCheckResult;
+    };
+    status: import("./frontend-standard.schema").CheckStatus;
+    findings: StandardFinding[];
+    summary: {
+        passed: number;
+        warnings: number;
+        errors: number;
+        nextSteps: string[];
+    };
+}>;

package/lib/standard/frontend-standard.service.js

@@ -0,0 +1,115 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.standardConfigPath = standardConfigPath;
+exports.loadFrontendStandard = loadFrontendStandard;
+exports.initFrontendStandard = initFrontendStandard;
+exports.scanFrontendProject = scanFrontendProject;
+exports.validateFrontendProject = validateFrontendProject;
+const fs = __importStar(require("fs/promises"));
+const frontend_standard_default_1 = require("./frontend-standard.default");
+const frontend_standard_schema_1 = require("./frontend-standard.schema");
+const project_files_1 = require("../filesystem/project-files");
+const project_scan_1 = require("./project-scan");
+const angular_structure_validator_1 = require("./validators/angular-structure.validator");
+const component_validator_1 = require("./validators/component.validator");
+const test_validator_1 = require("./validators/test.validator");
+function standardConfigPath(projectRoot) {
+    return (0, project_files_1.resolveNgManagerPath)(projectRoot, "frontend-standard.json");
+}
+async function loadFrontendStandard(project) {
+    const filePath = standardConfigPath(project.projectRoot);
+    try {
+        const raw = await fs.readFile(filePath, "utf-8");
+        return {
+            source: "file",
+            path: filePath,
+            standard: frontend_standard_schema_1.frontendStandardSchema.parse(JSON.parse(raw)),
+        };
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+        return {
+            source: "default",
+            path: filePath,
+            standard: frontend_standard_default_1.defaultFrontendStandard,
+        };
+    }
+}
+async function initFrontendStandard(project, overwrite = false) {
+    const filePath = standardConfigPath(project.projectRoot);
+    const exists = await (0, project_files_1.pathExists)(filePath);
+    if (exists && !overwrite) {
+        return {
+            status: "blocked",
+            path: filePath,
+            reason: "frontend-standard.json already exists; pass overwrite=true to replace it",
+        };
+    }
+    await (0, project_files_1.writeJsonFile)(filePath, frontend_standard_default_1.defaultFrontendStandard);
+    return {
+        status: "executed",
+        path: filePath,
+        changedFiles: [".ng-manager/frontend-standard.json"],
+        standard: frontend_standard_default_1.defaultFrontendStandard,
+    };
+}
+async function scanFrontendProject(projectRoot) {
+    const files = await (0, project_scan_1.listProjectFiles)(projectRoot);
+    return (0, project_scan_1.readSourceFiles)(files, (file) => file.path.endsWith(".ts") || file.path.endsWith("package.json"));
+}
+function mergeFindings(groups) {
+    return (0, frontend_standard_schema_1.summarizeFindings)(groups.flat());
+}
+async function validateFrontendProject(project, standard) {
+    const files = await scanFrontendProject(project.projectRoot);
+    const structure = (0, angular_structure_validator_1.validateAngularStructure)(files, standard);
+    const naming = (0, component_validator_1.validateComponentNaming)(files, standard);
+    const boundary = (0, component_validator_1.validateComponentBoundary)(files, standard);
+    const test = (0, test_validator_1.detectMissingSpecs)(files, standard);
+    const testNaming = (0, test_validator_1.validateSpecNaming)(files);
+    return {
+        ...mergeFindings([structure.findings, naming.findings, boundary.findings, test.findings, testNaming.findings]),
+        checks: {
+            structure,
+            componentNaming: naming,
+            componentBoundary: boundary,
+            missingSpecs: test,
+            testNaming,
+        },
+    };
+}

package/lib/standard/project-scan.d.ts

@@ -0,0 +1,9 @@
+export type SourceFile = {
+    path: string;
+    absolutePath: string;
+    text?: string;
+    lineCount?: number;
+};
+export declare function listProjectFiles(projectRoot: string, maxFiles?: number): Promise<SourceFile[]>;
+export declare function readSourceText(file: SourceFile, maxBytes?: number): Promise<SourceFile>;
+export declare function readSourceFiles(files: SourceFile[], predicate: (file: SourceFile) => boolean): Promise<SourceFile[]>;

package/lib/standard/project-scan.js

@@ -0,0 +1,91 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listProjectFiles = listProjectFiles;
+exports.readSourceText = readSourceText;
+exports.readSourceFiles = readSourceFiles;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const project_files_1 = require("../filesystem/project-files");
+const IGNORED_DIRS = new Set([".git", ".ng-manager", "node_modules", "dist", "lib", "coverage", ".angular", ".cache"]);
+async function listProjectFiles(projectRoot, maxFiles = 12000) {
+    const out = [];
+    async function visit(dir) {
+        if (out.length >= maxFiles)
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (out.length >= maxFiles)
+                return;
+            if (entry.isDirectory()) {
+                if (!IGNORED_DIRS.has(entry.name)) {
+                    await visit(path.join(dir, entry.name));
+                }
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            const absolutePath = path.join(dir, entry.name);
+            out.push({
+                path: (0, project_files_1.projectRelativePath)(projectRoot, absolutePath),
+                absolutePath,
+            });
+        }
+    }
+    await visit(projectRoot);
+    return out.sort((a, b) => a.path.localeCompare(b.path));
+}
+async function readSourceText(file, maxBytes = 250000) {
+    const stat = await fs.stat(file.absolutePath);
+    if (stat.size > maxBytes) {
+        return { ...file, text: "", lineCount: undefined };
+    }
+    const text = await fs.readFile(file.absolutePath, "utf-8");
+    return {
+        ...file,
+        text,
+        lineCount: text.split(/\r?\n/).length,
+    };
+}
+async function readSourceFiles(files, predicate) {
+    const selected = files.filter(predicate);
+    return Promise.all(selected.map((file) => readSourceText(file).catch(() => file)));
+}

package/lib/standard/validators/angular-structure.validator.d.ts

@@ -0,0 +1,4 @@
+import type { FrontendStandard, StandardFinding } from "../frontend-standard.schema";
+import type { SourceFile } from "../project-scan";
+export declare function validateAngularStructure(files: SourceFile[], standard: FrontendStandard): import("../frontend-standard.schema").StandardCheckResult;
+export declare function validatePagePlacement(files: SourceFile[], standard: FrontendStandard): StandardFinding[];

package/lib/standard/validators/angular-structure.validator.js

@@ -0,0 +1,75 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAngularStructure = validateAngularStructure;
+exports.validatePagePlacement = validatePagePlacement;
+const path = __importStar(require("path"));
+const frontend_standard_schema_1 = require("../frontend-standard.schema");
+function hasDirectory(files, dir) {
+    const normalized = dir.replace(/\\/g, "/").replace(/\/$/, "");
+    return files.some((file) => file.path === normalized || file.path.startsWith(`${normalized}/`));
+}
+function validateAngularStructure(files, standard) {
+    const findings = [];
+    for (const [key, dir] of Object.entries({
+        pages: standard.structure.pagesDir,
+        components: standard.structure.componentsDir,
+        services: standard.structure.servicesDir,
+        models: standard.structure.modelsDir,
+    })) {
+        if (!hasDirectory(files, dir)) {
+            findings.push({
+                ruleId: `angular.structure.${key}`,
+                severity: "warning",
+                message: `Expected Angular ${key} directory was not found: ${dir}`,
+                suggestion: `Create ${dir} when this project owns Angular ${key} code, or update frontend-standard.json for this project.`,
+            });
+        }
+    }
+    return (0, frontend_standard_schema_1.summarizeFindings)(findings);
+}
+function validatePagePlacement(files, standard) {
+    const pagesDir = standard.structure.pagesDir.replace(/\\/g, "/").replace(/\/$/, "");
+    return files
+        .filter((file) => file.path.endsWith(".page.ts") || path.basename(file.path).includes("-page.component."))
+        .filter((file) => !file.path.startsWith(`${pagesDir}/`))
+        .map((file) => ({
+        ruleId: "angular.page-placement",
+        severity: "warning",
+        message: `Page component is outside ${pagesDir}.`,
+        file: file.path,
+        suggestion: "Move route/page-level components under the configured pages directory.",
+    }));
+}

package/lib/standard/validators/component.validator.d.ts

@@ -0,0 +1,4 @@
+import type { FrontendStandard } from "../frontend-standard.schema";
+import type { SourceFile } from "../project-scan";
+export declare function validateComponentNaming(files: SourceFile[], standard: FrontendStandard): import("../frontend-standard.schema").StandardCheckResult;
+export declare function validateComponentBoundary(files: SourceFile[], standard: FrontendStandard): import("../frontend-standard.schema").StandardCheckResult;