@yinuo-ngm/mcp-server 0.1.2 → 0.1.4

package/lib/tools/project.tools.js

@@ -39,10 +39,18 @@ exports.projectTools = projectTools;
 const path = __importStar(require("path"));
 const zod_1 = require("zod");
 const result_1 = require("../utils/result");
+const workspace_tools_1 = require("./workspace.tools");
+const project_resolver_service_1 = require("../services/project-resolver.service");
 exports.projectLocatorSchema = zod_1.z.object({
     projectId: zod_1.z.string().trim().min(1).optional(),
     projectPath: zod_1.z.string().trim().min(1).optional(),
 }).strict();
+const projectFindSchema = zod_1.z.object({
+    query: zod_1.z.string().trim().min(1).optional(),
+    framework: zod_1.z.string().trim().min(1).optional(),
+    packageManager: zod_1.z.enum(["npm", "pnpm", "yarn"]).optional(),
+    projectPath: zod_1.z.string().trim().min(1).optional(),
+}).strict();
 async function resolveProject(context, locator) {
     if (locator.projectId) {
         return context.services.core.project.get(locator.projectId);
@@ -66,6 +74,7 @@ function toProjectSummary(project) {
     return {
         id: project.id,
         name: project.name,
+        path: project.root.replace(/\\/g, "/"),
         root: project.root,
         createdAt: project.createdAt,
         updatedAt: project.updatedAt,
@@ -82,6 +91,22 @@ function toProjectSummary(project) {
         assets: project.assets,
     };
 }
+function projectResolver(context) {
+    return context.services.projectResolver ?? new project_resolver_service_1.ProjectResolverService(context.services.core.project);
+}
+function scriptNames(project) {
+    return Object.keys(project.scripts ?? {}).sort();
+}
+function toMcpProjectItem(project) {
+    return {
+        id: project.id,
+        name: project.name,
+        path: project.root.replace(/\\/g, "/"),
+        framework: project.framework,
+        favorite: project.isFavorite,
+        scripts: scriptNames(project),
+    };
+}
 function toProjectScripts(project) {
     return {
         id: project.id,
@@ -96,33 +121,99 @@ function toProjectScripts(project) {
 function projectTools() {
     return [
         {
-            name: "ngm.project.list",
+            name: "ngm_project_list",
+            description: "List registered ng-manager projects by projectId. Prefer this MCP read tool before direct shell discovery because it uses the ng-manager project registry and does not scan arbitrary workspace roots.",
+            riskLevel: "read",
+            inputSchema: zod_1.z.object({}).strict(),
+            async handler(_args, context) {
+                const projects = await projectResolver(context).listProjects();
+                return (0, result_1.ok)("ngm_project_list", projects.map(toMcpProjectItem));
+            },
+        },
+        {
+            name: "ngm_project_managed_list",
             description: "List projects managed by ng-manager.",
             riskLevel: "read",
             inputSchema: zod_1.z.object({}).strict(),
             async handler(_args, context) {
                 const projects = await context.services.core.project.list();
-                return (0, result_1.ok)("ngm.project.list", projects.map(toProjectSummary));
+                return (0, result_1.ok)("ngm_project_managed_list", projects.map(toProjectSummary));
+            },
+        },
+        {
+            name: "ngm_project_find",
+            description: "Find ng-manager local projects by name, path, framework, package manager, or repository URL.",
+            riskLevel: "read",
+            inputSchema: projectFindSchema,
+            async handler(args, context) {
+                const projects = await context.services.core.project.list();
+                const query = args.query?.toLowerCase();
+                const requestedPath = args.projectPath ? normalizeFsPath(args.projectPath) : "";
+                const matched = projects.filter((project) => {
+                    if (args.packageManager && project.packageManager !== args.packageManager)
+                        return false;
+                    if (args.framework && String(project.framework ?? "").toLowerCase() !== args.framework.toLowerCase())
+                        return false;
+                    if (requestedPath && !normalizeFsPath(project.root).includes(requestedPath))
+                        return false;
+                    if (!query)
+                        return true;
+                    const text = [
+                        project.id,
+                        project.name,
+                        project.root,
+                        project.framework,
+                        project.packageManager,
+                        project.repoUrl,
+                        project.repoPageUrl,
+                    ]
+                        .filter(Boolean)
+                        .join(" ")
+                        .toLowerCase();
+                    return text.includes(query);
+                });
+                return (0, result_1.ok)("ngm_project_find", matched.map(toProjectSummary));
             },
         },
         {
-            name: "ngm.project.get",
+            name: "ngm_project_get",
             description: "Get one ng-manager project by projectId or projectPath.",
             riskLevel: "read",
             inputSchema: exports.projectLocatorSchema,
             async handler(args, context) {
                 const project = await resolveProject(context, args);
-                return (0, result_1.ok)("ngm.project.get", toProjectSummary(project));
+                return (0, result_1.ok)("ngm_project_get", toProjectSummary(project));
             },
         },
         {
-            name: "ngm.project.getScripts",
+            name: "ngm_project_get_scripts",
             description: "Get package scripts and runtime hints for one ng-manager project.",
             riskLevel: "read",
             inputSchema: exports.projectLocatorSchema,
             async handler(args, context) {
                 const project = await resolveProject(context, args);
-                return (0, result_1.ok)("ngm.project.getScripts", toProjectScripts(project));
+                return (0, result_1.ok)("ngm_project_get_scripts", toProjectScripts(project));
+            },
+        },
+        {
+            name: "ngm_project_read_package_json",
+            description: "Read package.json metadata for one registered ng-manager local project without running scripts.",
+            riskLevel: "read",
+            inputSchema: exports.projectLocatorSchema,
+            async handler(args, context) {
+                const project = await resolveProject(context, args);
+                const packageJson = await (0, workspace_tools_1.readWorkspacePackageJson)(context.workspaceRoot, project.root);
+                return (0, result_1.ok)("ngm_project_read_package_json", {
+                    project: {
+                        id: project.id,
+                        name: project.name,
+                        root: project.root,
+                        packageManager: project.packageManager,
+                        runtime: project.runtime,
+                        nodeVersion: project.nodeVersion,
+                    },
+                    packageJson,
+                });
             },
         },
     ];

package/lib/tools/proxy.tools.js

@@ -9,7 +9,7 @@ const proxyValidateSchema = zod_1.z.object({
 function proxyTools() {
     return [
         {
-            name: "ngm.proxy.list",
+            name: "ngm_proxy_list",
             description: "List current ng-manager Nginx/proxy binding, status, servers, and upstreams.",
             riskLevel: "read",
             inputSchema: zod_1.z.object({}).strict(),
@@ -24,7 +24,7 @@ function proxyTools() {
                     nginx.server.getAllServers().catch(() => []),
                     nginx.module.getUpstreams().catch(() => []),
                 ]);
-                return (0, result_1.ok)("ngm.proxy.list", {
+                return (0, result_1.ok)("ngm_proxy_list", {
                     instance,
                     status,
                     servers,
@@ -33,13 +33,13 @@ function proxyTools() {
             },
         },
         {
-            name: "ngm.proxy.validate",
+            name: "ngm_proxy_validate",
             description: "Validate the current or supplied ng-manager Nginx/proxy config without reload.",
             riskLevel: "read",
             inputSchema: proxyValidateSchema,
             async handler(args, context) {
                 const validation = await context.services.core.nginx.config.validateConfig(args.configText);
-                return (0, result_1.ok)("ngm.proxy.validate", validation);
+                return (0, result_1.ok)("ngm_proxy_validate", validation);
             },
         },
     ];

package/lib/tools/review/index.d.ts

@@ -0,0 +1 @@
+export { reviewTools } from "./review.tools";

package/lib/tools/review/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reviewTools = void 0;
+var review_tools_1 = require("./review.tools");
+Object.defineProperty(exports, "reviewTools", { enumerable: true, get: function () { return review_tools_1.reviewTools; } });

package/lib/tools/review/review.tools.d.ts

@@ -0,0 +1,2 @@
+import type { McpToolDefinition } from "../index";
+export declare function reviewTools(): McpToolDefinition[];

package/lib/tools/review/review.tools.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reviewTools = reviewTools;
+const zod_1 = require("zod");
+const result_1 = require("../../utils/result");
+const project_files_1 = require("../../filesystem/project-files");
+const operation_result_1 = require("../controlled/operation-result");
+const operation_policy_1 = require("../controlled/operation-policy");
+const frontend_standard_service_1 = require("../../standard/frontend-standard.service");
+const review_validator_1 = require("../../standard/validators/review.validator");
+const frontend_task_service_1 = require("../../workflow/frontend-task.service");
+const workflow_transition_1 = require("../../workflow/workflow-transition");
+const projectSchema = zod_1.z.object({
+    projectId: zod_1.z.string().trim().min(1).optional(),
+    projectPath: zod_1.z.string().trim().min(1).optional(),
+}).strict();
+const changedFilesSchema = projectSchema.extend({
+    changedFiles: zod_1.z.array(zod_1.z.string().trim().min(1)).optional(),
+}).strict();
+const reportSchema = changedFilesSchema.extend({
+    taskId: zod_1.z.string().trim().min(1),
+    confirm: zod_1.z.boolean().optional(),
+    dryRun: zod_1.z.boolean().optional(),
+}).strict();
+async function readChangedFiles(context, args, projectRoot) {
+    if (args.changedFiles)
+        return args.changedFiles.map((item) => item.replace(/\\/g, "/"));
+    const gitArgs = { ...args, projectPath: projectRoot };
+    if (!context.services.git.changedFiles)
+        return [];
+    try {
+        return await context.services.git.changedFiles(gitArgs);
+    }
+    catch {
+        return [];
+    }
+}
+function reviewTools() {
+    return [
+        {
+            name: "ngm_review_scan_changed_files",
+            description: "Read changed files from a fixed read-only git status command, or echo provided changedFiles.",
+            riskLevel: "read",
+            inputSchema: changedFilesSchema,
+            async handler(args, context) {
+                const project = await (0, project_files_1.resolveProjectRoot)(context, args);
+                const changedFiles = await readChangedFiles(context, args, project.projectRoot);
+                return (0, result_1.ok)("ngm_review_scan_changed_files", { project, changedFiles });
+            },
+        },
+        {
+            name: "ngm_review_generate_checklist",
+            description: "Generate a frontend code review checklist for the current changed files.",
+            riskLevel: "read",
+            inputSchema: changedFilesSchema,
+            async handler(args, context) {
+                const project = await (0, project_files_1.resolveProjectRoot)(context, args);
+                const changedFiles = await readChangedFiles(context, args, project.projectRoot);
+                return (0, result_1.ok)("ngm_review_generate_checklist", { changedFiles, checklist: (0, review_validator_1.reviewChecklist)(changedFiles) });
+            },
+        },
+        {
+            name: "ngm_review_detect_risks",
+            description: "Detect lightweight review risks in changed frontend files.",
+            riskLevel: "read",
+            inputSchema: changedFilesSchema,
+            async handler(args, context) {
+                const project = await (0, project_files_1.resolveProjectRoot)(context, args);
+                const loaded = await (0, frontend_standard_service_1.loadFrontendStandard)(project);
+                const changedFiles = await readChangedFiles(context, args, project.projectRoot);
+                const files = await (0, frontend_standard_service_1.scanFrontendProject)(project.projectRoot);
+                return (0, result_1.ok)("ngm_review_detect_risks", {
+                    changedFiles,
+                    ...(0, review_validator_1.detectReviewRisks)(files, changedFiles, loaded.standard),
+                });
+            },
+        },
+        {
+            name: "ngm_review_generate_report",
+            description: "Preview or write .ng-manager/reports/review-{taskId}.md with changed files, automated checks, risks, suggestions, and manual confirmation items.",
+            riskLevel: "write",
+            allowPreviewWhenBlocked: true,
+            deferPolicyToHandler: true,
+            isConfirmed: operation_result_1.isConfirmed,
+            inputSchema: reportSchema,
+            async handler(args, context) {
+                (0, project_files_1.validateSafeId)("taskId", args.taskId);
+                const project = await (0, project_files_1.resolveProjectRoot)(context, args);
+                const loaded = await (0, frontend_standard_service_1.loadFrontendStandard)(project);
+                const changedFiles = await readChangedFiles(context, args, project.projectRoot);
+                const files = await (0, frontend_standard_service_1.scanFrontendProject)(project.projectRoot);
+                const projectChecks = await (0, frontend_standard_service_1.validateFrontendProject)(project, loaded.standard);
+                const risks = (0, review_validator_1.detectReviewRisks)(files, changedFiles, loaded.standard);
+                const checklist = (0, review_validator_1.reviewChecklist)(changedFiles);
+                const markdown = (0, review_validator_1.generateReviewMarkdown)({
+                    taskId: args.taskId,
+                    changedFiles,
+                    checks: Object.entries(projectChecks.checks).map(([title, check]) => ({
+                        title,
+                        status: check.status,
+                        findings: check.findings,
+                    })),
+                    risks: risks.findings,
+                    checklist,
+                });
+                const reportPath = (0, frontend_task_service_1.taskFile)(project.projectRoot, args.taskId, "review-report.md");
+                const safetyMessage = "Write frontend code review report under project .ng-manager/frontend-tasks.";
+                const preview = {
+                    operation: (0, operation_result_1.operation)("preview", "write", "low", safetyMessage),
+                    project,
+                    taskId: args.taskId,
+                    path: (0, project_files_1.projectRelativePath)(project.projectRoot, reportPath),
+                    changedFiles,
+                    markdown,
+                };
+                if (!(0, operation_result_1.isConfirmed)(args))
+                    return (0, result_1.ok)("ngm_review_generate_report", preview);
+                const policyBlock = (0, operation_policy_1.requireWritePolicy)("low", safetyMessage);
+                if (policyBlock)
+                    return (0, result_1.ok)("ngm_review_generate_report", policyBlock);
+                try {
+                    const task = await (0, frontend_task_service_1.readFrontendTask)(project, args.taskId);
+                    if (!(0, workflow_transition_1.canTransitionWorkflowStatus)(task.status, "review-ready")) {
+                        return (0, result_1.ok)("ngm_review_generate_report", (0, operation_result_1.blocked)("write", "low", safetyMessage, (0, workflow_transition_1.workflowTransitionReason)(task.status, "review-ready")));
+                    }
+                    await (0, project_files_1.writeTextFile)(reportPath, markdown);
+                    await (0, frontend_task_service_1.updateFrontendTask)(project, args.taskId, {
+                        status: "review-ready",
+                        changedFiles,
+                        checks: {
+                            standard: projectChecks.status === "passed" || projectChecks.status === "warning" || projectChecks.status === "failed" || projectChecks.status === "blocked" ? projectChecks.status : "pending",
+                            test: projectChecks.checks.missingSpecs.status === "passed" || projectChecks.checks.missingSpecs.status === "warning" || projectChecks.checks.missingSpecs.status === "failed" || projectChecks.checks.missingSpecs.status === "blocked" ? projectChecks.checks.missingSpecs.status : "pending",
+                            review: risks.status === "passed" || risks.status === "warning" || risks.status === "failed" || risks.status === "blocked" ? risks.status : "pending",
+                            build: "pending",
+                        },
+                    });
+                }
+                catch (error) {
+                    return (0, result_1.ok)("ngm_review_generate_report", (0, operation_result_1.blocked)("write", "low", safetyMessage, error instanceof Error ? error.message : String(error)));
+                }
+                return (0, result_1.ok)("ngm_review_generate_report", {
+                    ...preview,
+                    operation: (0, operation_result_1.operation)("executed", "write", "low", safetyMessage),
+                    changedFiles: [
+                        (0, project_files_1.projectRelativePath)(project.projectRoot, reportPath),
+                        `.ng-manager/frontend-tasks/${args.taskId}/task.json`,
+                    ],
+                });
+            },
+        },
+    ];
+}

package/lib/tools/runtime/index.d.ts

@@ -0,0 +1 @@
+export { runtimeControlTools } from "./runtime-control.tools";

package/lib/tools/runtime/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runtimeControlTools = void 0;
+var runtime_control_tools_1 = require("./runtime-control.tools");
+Object.defineProperty(exports, "runtimeControlTools", { enumerable: true, get: function () { return runtime_control_tools_1.runtimeControlTools; } });

package/lib/tools/runtime/runtime-control.tools.d.ts

@@ -0,0 +1,2 @@
+import type { McpToolDefinition } from "../index";
+export declare function runtimeControlTools(): McpToolDefinition[];

package/lib/tools/runtime/runtime-control.tools.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runtimeControlTools = runtimeControlTools;
+const operation_result_1 = require("../controlled/operation-result");
+const result_1 = require("../../utils/result");
+const local_server_1 = require("../controlled/local-server");
+const operation_policy_1 = require("../controlled/operation-policy");
+const schemas_1 = require("../controlled/schemas");
+const runtime_config_1 = require("../project/runtime-config");
+const project_resolver_service_1 = require("../../services/project-resolver.service");
+const error_codes_1 = require("../../errors/error-codes");
+function projectResolver(context) {
+    return context.services.projectResolver ?? new project_resolver_service_1.ProjectResolverService(context.services.core.project);
+}
+function runtimeControlTools() {
+    return [
+        {
+            name: "ngm_runtime_set_for_project",
+            description: "Skill ngm-runtime. Controlled write tool for binding a registered ng-manager projectId to a Node runtime config through the local ng-manager server. Prefer this over editing config files or shell profiles because it preserves server/UI state and audit. Previews by default; real write requires confirm=true and NGM_MCP_ALLOW_WRITE=true. It does not modify system PATH, nvm, shell profiles, or install runtimes.",
+            riskLevel: "write",
+            allowPreviewWhenBlocked: true,
+            deferPolicyToHandler: true,
+            isConfirmed: operation_result_1.isConfirmed,
+            inputSchema: schemas_1.setRuntimeSchema,
+            async handler(args, context) {
+                const confirmed = (0, operation_result_1.isConfirmed)(args);
+                if (confirmed) {
+                    const policyBlock = (0, operation_policy_1.requireWritePolicy)("medium", `Set Node runtime binding for registered project "${args.projectId}".`);
+                    if (policyBlock)
+                        return (0, result_1.ok)("ngm_runtime_set_for_project", { ...(0, operation_result_1.controlledFields)("write", true, (0, operation_policy_1.requiredEnv)("write")), ...policyBlock });
+                }
+                const project = await projectResolver(context).resolveProject(args.projectId);
+                const nextRuntime = (0, runtime_config_1.toRuntimeConfig)(args.runtime);
+                (0, runtime_config_1.validateTargetRuntime)(nextRuntime);
+                const safetyMessage = `Set Node runtime binding for managed project "${project.name}".`;
+                const oldRuntime = (0, runtime_config_1.runtimeConfigForProject)(project);
+                let resolvedRuntime;
+                try {
+                    resolvedRuntime = await context.services.core.nodeRuntime.resolveRuntime(nextRuntime);
+                }
+                catch (error) {
+                    return (0, result_1.ok)("ngm_runtime_set_for_project", (0, operation_result_1.blocked)("write", "medium", safetyMessage, "target runtime could not be resolved", {
+                        error: error instanceof Error ? error.message : String(error),
+                        nextStep: "Install or register the target Node runtime before binding the project.",
+                        project: { id: project.id, name: project.name, root: project.root },
+                        oldRuntime,
+                        newRuntime: nextRuntime,
+                    }));
+                }
+                const preview = {
+                    ...(0, operation_result_1.controlledFields)("write", confirmed, (0, operation_policy_1.requiredEnv)("write")),
+                    operation: (0, operation_result_1.operation)("preview", "write", "medium", safetyMessage),
+                    project: { id: project.id, name: project.name, root: project.root },
+                    diff: { oldRuntime, newRuntime: nextRuntime },
+                    resolvedRuntime,
+                };
+                if (!confirmed)
+                    return (0, result_1.ok)("ngm_runtime_set_for_project", preview);
+                const serverCheck = await (0, local_server_1.requireLocalServer)(context);
+                if (!serverCheck.server) {
+                    return (0, result_1.ok)("ngm_runtime_set_for_project", (0, operation_result_1.blocked)("write", "medium", safetyMessage, "ng-manager local server is unavailable; start ngm server or ngm ui before writing project runtime config", {
+                        ...(0, operation_result_1.controlledFields)("write", true, (0, operation_policy_1.requiredEnv)("write")),
+                        localServer: serverCheck.availability,
+                        project: { id: project.id, name: project.name, root: project.root },
+                        oldRuntime,
+                        newRuntime: nextRuntime,
+                    }, error_codes_1.McpErrorCodes.LOCAL_SERVER_UNAVAILABLE));
+                }
+                const updatedProject = await serverCheck.server.updateProjectRuntime(project.id, nextRuntime);
+                const verifiedRuntime = await context.services.core.nodeRuntime.resolveRuntime(nextRuntime);
+                return (0, result_1.ok)("ngm_runtime_set_for_project", {
+                    ...preview,
+                    ...(0, operation_result_1.controlledFields)("write", true, (0, operation_policy_1.requiredEnv)("write")),
+                    operation: (0, operation_result_1.operation)("executed", "write", "medium", safetyMessage),
+                    controlPlane: "local-server",
+                    localServer: serverCheck.availability,
+                    project: {
+                        id: updatedProject.id,
+                        name: updatedProject.name,
+                        root: updatedProject.root,
+                        runtime: updatedProject.runtime,
+                        nodeVersion: updatedProject.nodeVersion,
+                    },
+                    verifiedRuntime,
+                });
+            },
+        },
+    ];
+}

package/lib/tools/runtime.tools.js

@@ -29,17 +29,27 @@ function runtimeConfigForProject(project) {
 function runtimeTools() {
     return [
         {
-            name: "ngm.runtime.list",
+            name: "ngm_runtime_current",
+            description: "Read current Node version manager information known to ng-manager.",
+            riskLevel: "read",
+            inputSchema: zod_1.z.object({}).strict(),
+            async handler(_args, context) {
+                const current = await context.services.core.nodeVersion.getCurrentVersion();
+                return (0, result_1.ok)("ngm_runtime_current", current);
+            },
+        },
+        {
+            name: "ngm_runtime_list",
             description: "List Node runtimes known to ng-manager.",
             riskLevel: "read",
             inputSchema: zod_1.z.object({}).strict(),
             async handler(_args, context) {
                 const runtimes = await context.services.core.nodeRuntime.listRuntimes();
-                return (0, result_1.ok)("ngm.runtime.list", runtimes);
+                return (0, result_1.ok)("ngm_runtime_list", runtimes);
             },
         },
         {
-            name: "ngm.runtime.resolveForProject",
+            name: "ngm_runtime_resolve_for_project",
             description: "Resolve the Node runtime ng-manager would use for a project.",
             riskLevel: "read",
             inputSchema: project_tools_1.projectLocatorSchema,
@@ -47,7 +57,7 @@ function runtimeTools() {
                 const project = await (0, project_tools_1.resolveProject)(context, args);
                 const requestedRuntime = runtimeConfigForProject(project);
                 const resolvedRuntime = await context.services.core.nodeRuntime.resolveRuntime(requestedRuntime);
-                return (0, result_1.ok)("ngm.runtime.resolveForProject", {
+                return (0, result_1.ok)("ngm_runtime_resolve_for_project", {
                     project: {
                         id: project.id,
                         name: project.name,
@@ -61,5 +71,32 @@ function runtimeTools() {
                 });
             },
         },
+        {
+            name: "ngm_runtime_detect_requirement",
+            description: "Detect Node version requirements for a project path or registered ng-manager project.",
+            riskLevel: "read",
+            inputSchema: project_tools_1.projectLocatorSchema,
+            async handler(args, context) {
+                let projectPath = args.projectPath;
+                let project;
+                if (args.projectId) {
+                    const resolvedProject = await (0, project_tools_1.resolveProject)(context, { projectId: args.projectId });
+                    projectPath = resolvedProject.root;
+                    project = {
+                        id: resolvedProject.id,
+                        name: resolvedProject.name,
+                        root: resolvedProject.root,
+                    };
+                }
+                if (!projectPath) {
+                    throw new Error("projectId or projectPath is required");
+                }
+                const requirement = await context.services.core.nodeVersion.detectProjectRequirement(projectPath);
+                return (0, result_1.ok)("ngm_runtime_detect_requirement", {
+                    project,
+                    requirement,
+                });
+            },
+        },
     ];
 }

package/lib/tools/standard/index.d.ts

@@ -0,0 +1 @@
+export { standardTools } from "./standard.tools";

package/lib/tools/standard/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.standardTools = void 0;
+var standard_tools_1 = require("./standard.tools");
+Object.defineProperty(exports, "standardTools", { enumerable: true, get: function () { return standard_tools_1.standardTools; } });

package/lib/tools/standard/standard.tools.d.ts

@@ -0,0 +1,2 @@
+import type { McpToolDefinition } from "../index";
+export declare function standardTools(): McpToolDefinition[];

package/lib/tools/standard/standard.tools.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.standardTools = standardTools;
+const zod_1 = require("zod");
+const result_1 = require("../../utils/result");
+const project_files_1 = require("../../filesystem/project-files");
+const operation_result_1 = require("../controlled/operation-result");
+const operation_policy_1 = require("../controlled/operation-policy");
+const frontend_standard_service_1 = require("../../standard/frontend-standard.service");
+const projectSchema = zod_1.z.object({
+    projectId: zod_1.z.string().trim().min(1).optional(),
+    projectPath: zod_1.z.string().trim().min(1).optional(),
+}).strict();
+const initSchema = projectSchema.extend({
+    overwrite: zod_1.z.boolean().optional(),
+    confirm: zod_1.z.boolean().optional(),
+    dryRun: zod_1.z.boolean().optional(),
+}).strict();
+function standardTools() {
+    return [
+        {
+            name: "ngm_standard_get",
+            description: "Read the frontend standard config for a project, returning defaults when .ng-manager/frontend-standard.json does not exist.",
+            riskLevel: "read",
+            inputSchema: projectSchema,
+            async handler(args, context) {
+                const project = await (0, project_files_1.resolveProjectRoot)(context, args);
+                const loaded = await (0, frontend_standard_service_1.loadFrontendStandard)(project);
+                return (0, result_1.ok)("ngm_standard_get", {
+                    project,
+                    source: loaded.source,
+                    path: (0, project_files_1.projectRelativePath)(project.projectRoot, loaded.path),
+                    standard: loaded.standard,
+                });
+            },
+        },
+        {
+            name: "ngm_standard_init",
+            description: "Preview or create .ng-manager/frontend-standard.json for a project. Requires confirm=true and NGM_MCP_ALLOW_WRITE=true to write.",
+            riskLevel: "write",
+            allowPreviewWhenBlocked: true,
+            deferPolicyToHandler: true,
+            isConfirmed: operation_result_1.isConfirmed,
+            inputSchema: initSchema,
+            async handler(args, context) {
+                const project = await (0, project_files_1.resolveProjectRoot)(context, args);
+                const loaded = await (0, frontend_standard_service_1.loadFrontendStandard)(project);
+                const safetyMessage = "Create or replace project frontend standard configuration.";
+                const preview = {
+                    operation: (0, operation_result_1.operation)("preview", "write", "low", safetyMessage),
+                    project,
+                    path: (0, project_files_1.projectRelativePath)(project.projectRoot, loaded.path),
+                    standard: loaded.standard,
+                };
+                if (!(0, operation_result_1.isConfirmed)(args))
+                    return (0, result_1.ok)("ngm_standard_init", preview);
+                const policyBlock = (0, operation_policy_1.requireWritePolicy)("low", safetyMessage);
+                if (policyBlock)
+                    return (0, result_1.ok)("ngm_standard_init", policyBlock);
+                const result = await (0, frontend_standard_service_1.initFrontendStandard)(project, args.overwrite === true);
+                if (result.status === "blocked") {
+                    return (0, result_1.ok)("ngm_standard_init", (0, operation_result_1.blocked)("write", "low", safetyMessage, result.reason ?? "frontend standard init was blocked", {
+                        path: (0, project_files_1.projectRelativePath)(project.projectRoot, result.path),
+                    }));
+                }
+                return (0, result_1.ok)("ngm_standard_init", {
+                    ...preview,
+                    operation: (0, operation_result_1.operation)("executed", "write", "low", safetyMessage),
+                    path: (0, project_files_1.projectRelativePath)(project.projectRoot, result.path),
+                    changedFiles: result.changedFiles,
+                });
+            },
+        },
+        {
+            name: "ngm_standard_validate_project",
+            description: "Run lightweight frontend standard checks for Angular structure, component boundaries, and test naming.",
+            riskLevel: "read",
+            inputSchema: projectSchema,
+            async handler(args, context) {
+                const project = await (0, project_files_1.resolveProjectRoot)(context, args);
+                const loaded = await (0, frontend_standard_service_1.loadFrontendStandard)(project);
+                const result = await (0, frontend_standard_service_1.validateFrontendProject)(project, loaded.standard);
+                return (0, result_1.ok)("ngm_standard_validate_project", {
+                    project,
+                    standardSource: loaded.source,
+                    ...result,
+                });
+            },
+        },
+    ];
+}