@yinuo-ngm/mcp-server 0.1.2 → 0.1.4

package/lib/tools/task.tools.js

@@ -12,27 +12,62 @@ const taskStatusSchema = zod_1.z.object({
 function taskTools() {
     return [
         {
-            name: "ngm.task.list",
+            name: "ngm_task_list",
             description: "List registered task views for a project, or active tasks when projectId is omitted.",
             riskLevel: "read",
             inputSchema: taskListSchema,
             async handler(args, context) {
-                if (args.projectId) {
-                    const rows = await context.services.core.task.listViewsByProject(args.projectId);
-                    return (0, result_1.ok)("ngm.task.list", rows);
+                const localServer = context.services.localServer;
+                const availability = localServer ? await localServer.availability() : { available: false, reason: "local server client is not configured" };
+                if (availability.available && localServer) {
+                    if (args.projectId) {
+                        const rows = await localServer.listTaskViews(args.projectId);
+                        return (0, result_1.ok)("ngm_task_list", {
+                            controlPlane: "local-server",
+                            localServer: availability,
+                            rows,
+                        });
+                    }
+                    const activeTasks = await localServer.listActiveTasks();
+                    return (0, result_1.ok)("ngm_task_list", {
+                        controlPlane: "local-server",
+                        localServer: availability,
+                        activeTasks,
+                    });
                 }
-                const activeTasks = await context.services.core.task.listActive();
-                return (0, result_1.ok)("ngm.task.list", activeTasks);
+                return (0, result_1.ok)("ngm_task_list", {
+                    controlPlane: "unavailable",
+                    localServer: availability,
+                    status: "unavailable",
+                    reason: "ng-manager local server is not running; start it with ngm server or ngm ui to inspect shared task state",
+                    rows: args.projectId ? [] : undefined,
+                    activeTasks: args.projectId ? undefined : [],
+                });
             },
         },
         {
-            name: "ngm.task.getStatus",
+            name: "ngm_task_get_status",
             description: "Get the runtime status for a registered task.",
             riskLevel: "read",
             inputSchema: taskStatusSchema,
             async handler(args, context) {
-                const runtime = await context.services.core.task.status(args.taskId);
-                return (0, result_1.ok)("ngm.task.getStatus", runtime);
+                const localServer = context.services.localServer;
+                const availability = localServer ? await localServer.availability() : { available: false, reason: "local server client is not configured" };
+                if (availability.available && localServer) {
+                    const runtime = await localServer.getTaskStatus(args.taskId);
+                    return (0, result_1.ok)("ngm_task_get_status", {
+                        controlPlane: "local-server",
+                        localServer: availability,
+                        runtime,
+                    });
+                }
+                return (0, result_1.ok)("ngm_task_get_status", {
+                    controlPlane: "unavailable",
+                    localServer: availability,
+                    status: "unavailable",
+                    reason: "ng-manager local server is not running; start it with ngm server or ngm ui to inspect shared task state",
+                    taskId: args.taskId,
+                });
             },
         },
     ];

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

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

package/lib/tools/test/index.js

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

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

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

package/lib/tools/test/test-standard.tools.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testStandardTools = testStandardTools;
+const zod_1 = require("zod");
+const result_1 = require("../../utils/result");
+const project_files_1 = require("../../filesystem/project-files");
+const frontend_standard_service_1 = require("../../standard/frontend-standard.service");
+const test_validator_1 = require("../../standard/validators/test.validator");
+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();
+function testStandardTools() {
+    return [
+        {
+            name: "ngm_test_detect_missing_specs",
+            description: "Detect service/util/complex component files that should have frontend spec coverage. MVP emits warnings only.",
+            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 files = await (0, frontend_standard_service_1.scanFrontendProject)(project.projectRoot);
+                return (0, result_1.ok)("ngm_test_detect_missing_specs", (0, test_validator_1.detectMissingSpecs)(files, loaded.standard));
+            },
+        },
+        {
+            name: "ngm_test_generate_spec_plan",
+            description: "Generate a lightweight spec plan for missing service/util/component specs.",
+            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 files = await (0, frontend_standard_service_1.scanFrontendProject)(project.projectRoot);
+                return (0, result_1.ok)("ngm_test_generate_spec_plan", (0, test_validator_1.generateSpecPlan)(files, loaded.standard));
+            },
+        },
+        {
+            name: "ngm_test_validate_naming",
+            description: "Validate frontend test file naming, preferring Angular .spec.ts files.",
+            riskLevel: "read",
+            inputSchema: projectSchema,
+            async handler(args, context) {
+                const project = await (0, project_files_1.resolveProjectRoot)(context, args);
+                const files = await (0, frontend_standard_service_1.scanFrontendProject)(project.projectRoot);
+                return (0, result_1.ok)("ngm_test_validate_naming", (0, test_validator_1.validateSpecNaming)(files));
+            },
+        },
+    ];
+}

package/lib/tools/tool-catalog.d.ts

@@ -0,0 +1,2 @@
+export { blockedLocalActions, capabilityCatalog, toolCatalog } from "../catalog";
+export type { CapabilityCatalogEntry, ToolCatalogEntry } from "../catalog/types";

package/lib/tools/tool-catalog.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolCatalog = exports.capabilityCatalog = exports.blockedLocalActions = void 0;
+var catalog_1 = require("../catalog");
+Object.defineProperty(exports, "blockedLocalActions", { enumerable: true, get: function () { return catalog_1.blockedLocalActions; } });
+Object.defineProperty(exports, "capabilityCatalog", { enumerable: true, get: function () { return catalog_1.capabilityCatalog; } });
+Object.defineProperty(exports, "toolCatalog", { enumerable: true, get: function () { return catalog_1.toolCatalog; } });

package/lib/tools/workflow/frontend-workflow.tools.d.ts

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

package/lib/tools/workflow/frontend-workflow.tools.js

@@ -0,0 +1,364 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.frontendWorkflowTools = frontendWorkflowTools;
+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 test_validator_1 = require("../../standard/validators/test.validator");
+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 createTaskSchema = projectSchema.extend({
+    taskId: zod_1.z.string().trim().min(1).optional(),
+    title: zod_1.z.string().trim().min(1),
+    description: zod_1.z.string().trim().optional(),
+    confirm: zod_1.z.boolean().optional(),
+    dryRun: zod_1.z.boolean().optional(),
+}).strict();
+const devPlanSchema = projectSchema.extend({
+    taskId: zod_1.z.string().trim().min(1),
+    title: zod_1.z.string().trim().min(1).optional(),
+    context: zod_1.z.string().optional(),
+    acceptance: zod_1.z.array(zod_1.z.string().trim().min(1)).optional(),
+    confirm: zod_1.z.boolean().optional(),
+    dryRun: zod_1.z.boolean().optional(),
+}).strict();
+const validateSchema = projectSchema.extend({
+    taskId: zod_1.z.string().trim().min(1).optional(),
+    confirm: zod_1.z.boolean().optional(),
+    dryRun: zod_1.z.boolean().optional(),
+}).strict();
+const deliverySchema = projectSchema.extend({
+    taskId: zod_1.z.string().trim().min(1),
+    summary: zod_1.z.string().trim().min(1),
+    verification: zod_1.z.array(zod_1.z.string().trim().min(1)).optional(),
+    risks: zod_1.z.array(zod_1.z.string().trim().min(1)).optional(),
+    confirm: zod_1.z.boolean().optional(),
+    dryRun: zod_1.z.boolean().optional(),
+}).strict();
+const advanceStatusSchema = projectSchema.extend({
+    taskId: zod_1.z.string().trim().min(1),
+    nextStatus: zod_1.z.enum(["context-ready", "patch-ready", "applied", "verified", "review-ready", "failed"]),
+    note: zod_1.z.string().trim().optional(),
+    confirm: zod_1.z.boolean().optional(),
+    dryRun: zod_1.z.boolean().optional(),
+}).strict();
+function writePreview(tool, safetyMessage, data) {
+    return (0, result_1.ok)(tool, {
+        operation: (0, operation_result_1.operation)("preview", "write", "low", safetyMessage),
+        ...data,
+    });
+}
+function toWorkflowCheckStatus(status) {
+    return status === "passed" || status === "warning" || status === "failed" || status === "blocked" ? status : "pending";
+}
+function aggregateValidationStatus(results) {
+    if (results.some((item) => item.status === "failed"))
+        return "failed";
+    if (results.some((item) => item.status === "blocked"))
+        return "blocked";
+    if (results.some((item) => item.status === "warning"))
+        return "warning";
+    return "passed";
+}
+function transitionBlocked(toolName, safetyMessage, error) {
+    if (error instanceof workflow_transition_1.WorkflowTransitionError) {
+        return (0, result_1.ok)(toolName, (0, operation_result_1.blocked)("write", "low", safetyMessage, (0, workflow_transition_1.workflowTransitionReason)(error.from, error.to)));
+    }
+    throw error;
+}
+async function readChangedFiles(context, args, projectRoot) {
+    if (!context.services.git.changedFiles)
+        return [];
+    try {
+        return await context.services.git.changedFiles({ ...args, projectPath: projectRoot });
+    }
+    catch {
+        return [];
+    }
+}
+function frontendWorkflowTools() {
+    return [
+        {
+            name: "ngm_workflow_create_frontend_task",
+            description: "Preview or create .ng-manager/frontend-tasks/{taskId}/task.json for a frontend workflow task.",
+            riskLevel: "write",
+            allowPreviewWhenBlocked: true,
+            deferPolicyToHandler: true,
+            isConfirmed: operation_result_1.isConfirmed,
+            inputSchema: createTaskSchema,
+            async handler(args, context) {
+                const project = await (0, project_files_1.resolveProjectRoot)(context, args);
+                const taskId = args.taskId || (0, frontend_task_service_1.createTaskId)(args.title);
+                const safetyMessage = "Create frontend workflow task metadata under project .ng-manager/frontend-tasks.";
+                if (!(0, operation_result_1.isConfirmed)(args)) {
+                    return writePreview("ngm_workflow_create_frontend_task", safetyMessage, {
+                        project,
+                        task: { taskId, title: args.title, description: args.description, status: "draft" },
+                    });
+                }
+                const policyBlock = (0, operation_policy_1.requireWritePolicy)("low", safetyMessage);
+                if (policyBlock)
+                    return (0, result_1.ok)("ngm_workflow_create_frontend_task", policyBlock);
+                const result = await (0, frontend_task_service_1.createFrontendTask)(project, {
+                    taskId: args.taskId,
+                    title: args.title,
+                    description: args.description,
+                });
+                if (result.status === "blocked") {
+                    return (0, result_1.ok)("ngm_workflow_create_frontend_task", (0, operation_result_1.blocked)("write", "low", safetyMessage, result.reason, {
+                        taskId: result.taskId,
+                    }));
+                }
+                return (0, result_1.ok)("ngm_workflow_create_frontend_task", {
+                    operation: (0, operation_result_1.operation)("executed", "write", "low", safetyMessage),
+                    project,
+                    task: result.task,
+                    changedFiles: result.changedFiles,
+                });
+            },
+        },
+        {
+            name: "ngm_workflow_generate_dev_plan",
+            description: "Preview or write .ng-manager/frontend-tasks/{taskId}/dev-plan.md and advance task status to plan-ready.",
+            riskLevel: "write",
+            allowPreviewWhenBlocked: true,
+            deferPolicyToHandler: true,
+            isConfirmed: operation_result_1.isConfirmed,
+            inputSchema: devPlanSchema,
+            async handler(args, context) {
+                const project = await (0, project_files_1.resolveProjectRoot)(context, args);
+                const task = await (0, frontend_task_service_1.readFrontendTask)(project, args.taskId).catch(() => undefined);
+                const title = args.title || task?.title || args.taskId;
+                const markdown = (0, frontend_task_service_1.devPlanMarkdown)({ taskId: args.taskId, title, context: args.context, acceptance: args.acceptance });
+                const safetyMessage = "Write frontend development plan under project .ng-manager/frontend-tasks.";
+                if (!(0, operation_result_1.isConfirmed)(args)) {
+                    return writePreview("ngm_workflow_generate_dev_plan", safetyMessage, { project, taskId: args.taskId, markdown });
+                }
+                const policyBlock = (0, operation_policy_1.requireWritePolicy)("low", safetyMessage);
+                if (policyBlock)
+                    return (0, result_1.ok)("ngm_workflow_generate_dev_plan", policyBlock);
+                if (!task)
+                    return (0, result_1.ok)("ngm_workflow_generate_dev_plan", (0, operation_result_1.blocked)("write", "low", safetyMessage, "task.json was not found; create the frontend task first"));
+                let result;
+                try {
+                    result = await (0, frontend_task_service_1.writeTaskMarkdown)(project, args.taskId, "dev-plan.md", markdown, "plan-ready");
+                }
+                catch (error) {
+                    return transitionBlocked("ngm_workflow_generate_dev_plan", safetyMessage, error);
+                }
+                return (0, result_1.ok)("ngm_workflow_generate_dev_plan", {
+                    operation: (0, operation_result_1.operation)("executed", "write", "low", safetyMessage),
+                    project,
+                    task: result.task,
+                    changedFiles: result.changedFiles,
+                });
+            },
+        },
+        {
+            name: "ngm_workflow_advance_status",
+            description: "Preview or advance a frontend workflow task status through the controlled workflow transition graph.",
+            riskLevel: "write",
+            allowPreviewWhenBlocked: true,
+            deferPolicyToHandler: true,
+            isConfirmed: operation_result_1.isConfirmed,
+            inputSchema: advanceStatusSchema,
+            async handler(args, context) {
+                const project = await (0, project_files_1.resolveProjectRoot)(context, args);
+                const task = await (0, frontend_task_service_1.readFrontendTask)(project, args.taskId).catch(() => undefined);
+                const safetyMessage = "Advance frontend workflow task status in task.json.";
+                if (!(0, operation_result_1.isConfirmed)(args)) {
+                    return writePreview("ngm_workflow_advance_status", safetyMessage, {
+                        project,
+                        taskId: args.taskId,
+                        fromStatus: task?.status,
+                        nextStatus: args.nextStatus,
+                        note: args.note,
+                    });
+                }
+                const policyBlock = (0, operation_policy_1.requireWritePolicy)("low", safetyMessage);
+                if (policyBlock)
+                    return (0, result_1.ok)("ngm_workflow_advance_status", policyBlock);
+                if (!task)
+                    return (0, result_1.ok)("ngm_workflow_advance_status", (0, operation_result_1.blocked)("write", "low", safetyMessage, "task.json was not found; create the frontend task first"));
+                let updated;
+                try {
+                    updated = await (0, frontend_task_service_1.updateTaskStatus)(project, args.taskId, args.nextStatus);
+                }
+                catch (error) {
+                    return transitionBlocked("ngm_workflow_advance_status", safetyMessage, error);
+                }
+                return (0, result_1.ok)("ngm_workflow_advance_status", {
+                    operation: (0, operation_result_1.operation)("executed", "write", "low", safetyMessage),
+                    project,
+                    task: updated,
+                    note: args.note,
+                    changedFiles: [`.ng-manager/frontend-tasks/${args.taskId}/task.json`],
+                });
+            },
+        },
+        {
+            name: "ngm_workflow_validate_before_write",
+            description: "Preview or persist lightweight frontend project validation before AI writes source changes.",
+            riskLevel: "write",
+            allowPreviewWhenBlocked: true,
+            deferPolicyToHandler: true,
+            isConfirmed: operation_result_1.isConfirmed,
+            inputSchema: validateSchema,
+            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 validation = await (0, frontend_standard_service_1.validateFrontendProject)(project, loaded.standard);
+                const test = validation.checks.missingSpecs;
+                const checks = {
+                    standard: toWorkflowCheckStatus(validation.status),
+                    test: toWorkflowCheckStatus(test.status),
+                    review: "pending",
+                    build: "pending",
+                };
+                const safetyMessage = "Update frontend workflow pre-write checks in task.json.";
+                const preview = {
+                    operation: (0, operation_result_1.operation)("preview", "write", "low", safetyMessage),
+                    project,
+                    taskId: args.taskId,
+                    checks,
+                    validation,
+                };
+                if (!args.taskId || !(0, operation_result_1.isConfirmed)(args))
+                    return (0, result_1.ok)("ngm_workflow_validate_before_write", preview);
+                const policyBlock = (0, operation_policy_1.requireWritePolicy)("low", safetyMessage);
+                if (policyBlock)
+                    return (0, result_1.ok)("ngm_workflow_validate_before_write", policyBlock);
+                let task;
+                try {
+                    task = await (0, frontend_task_service_1.updateFrontendTask)(project, args.taskId, { checks });
+                }
+                catch (error) {
+                    return transitionBlocked("ngm_workflow_validate_before_write", safetyMessage, error);
+                }
+                return (0, result_1.ok)("ngm_workflow_validate_before_write", {
+                    ...preview,
+                    operation: (0, operation_result_1.operation)("executed", "write", "low", safetyMessage),
+                    task,
+                    changedFiles: [`.ng-manager/frontend-tasks/${args.taskId}/task.json`],
+                });
+            },
+        },
+        {
+            name: "ngm_workflow_validate_before_commit",
+            description: "Preview or persist frontend standard/test/review/Git checks before commit.",
+            riskLevel: "write",
+            allowPreviewWhenBlocked: true,
+            deferPolicyToHandler: true,
+            isConfirmed: operation_result_1.isConfirmed,
+            inputSchema: validateSchema,
+            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 validation = await (0, frontend_standard_service_1.validateFrontendProject)(project, loaded.standard);
+                const files = await (0, frontend_standard_service_1.scanFrontendProject)(project.projectRoot);
+                const changedFiles = await readChangedFiles(context, args, project.projectRoot);
+                const test = (0, test_validator_1.detectMissingSpecs)(files, loaded.standard);
+                const review = (0, review_validator_1.detectReviewRisks)(files, changedFiles, loaded.standard);
+                const aggregateStatus = aggregateValidationStatus([validation, test, review]);
+                const checks = {
+                    standard: toWorkflowCheckStatus(validation.status),
+                    test: toWorkflowCheckStatus(test.status),
+                    review: toWorkflowCheckStatus(review.status),
+                    build: "pending",
+                };
+                const safetyMessage = "Update frontend workflow pre-commit checks in task.json.";
+                const preview = {
+                    operation: (0, operation_result_1.operation)("preview", "write", "low", safetyMessage),
+                    project,
+                    taskId: args.taskId,
+                    status: aggregateStatus,
+                    changedFiles,
+                    checks,
+                    standard: validation,
+                    test,
+                    review,
+                    git: {
+                        changedFiles,
+                    },
+                };
+                if (!args.taskId || !(0, operation_result_1.isConfirmed)(args))
+                    return (0, result_1.ok)("ngm_workflow_validate_before_commit", preview);
+                const policyBlock = (0, operation_policy_1.requireWritePolicy)("low", safetyMessage);
+                if (policyBlock)
+                    return (0, result_1.ok)("ngm_workflow_validate_before_commit", policyBlock);
+                let task;
+                try {
+                    const current = await (0, frontend_task_service_1.readFrontendTask)(project, args.taskId);
+                    const statusPatch = aggregateStatus === "failed" || aggregateStatus === "blocked"
+                        ? { status: "failed" }
+                        : current.status === "applied"
+                            ? { status: "verified" }
+                            : {};
+                    task = await (0, frontend_task_service_1.updateFrontendTask)(project, args.taskId, {
+                        checks,
+                        changedFiles,
+                        ...statusPatch,
+                    });
+                }
+                catch (error) {
+                    return transitionBlocked("ngm_workflow_validate_before_commit", safetyMessage, error);
+                }
+                return (0, result_1.ok)("ngm_workflow_validate_before_commit", {
+                    ...preview,
+                    operation: (0, operation_result_1.operation)("executed", "write", "low", safetyMessage),
+                    task,
+                    changedFiles: [`.ng-manager/frontend-tasks/${args.taskId}/task.json`],
+                });
+            },
+        },
+        {
+            name: "ngm_workflow_generate_delivery_report",
+            description: "Preview or write .ng-manager/frontend-tasks/{taskId}/delivery-report.md and advance task status to delivered.",
+            riskLevel: "write",
+            allowPreviewWhenBlocked: true,
+            deferPolicyToHandler: true,
+            isConfirmed: operation_result_1.isConfirmed,
+            inputSchema: deliverySchema,
+            async handler(args, context) {
+                const project = await (0, project_files_1.resolveProjectRoot)(context, args);
+                const markdown = (0, frontend_task_service_1.deliveryReportMarkdown)({
+                    taskId: args.taskId,
+                    summary: args.summary,
+                    verification: args.verification,
+                    risks: args.risks,
+                });
+                const safetyMessage = "Write frontend delivery report under project .ng-manager/frontend-tasks.";
+                if (!(0, operation_result_1.isConfirmed)(args)) {
+                    return writePreview("ngm_workflow_generate_delivery_report", safetyMessage, { project, taskId: args.taskId, markdown });
+                }
+                const policyBlock = (0, operation_policy_1.requireWritePolicy)("low", safetyMessage);
+                if (policyBlock)
+                    return (0, result_1.ok)("ngm_workflow_generate_delivery_report", policyBlock);
+                const task = await (0, frontend_task_service_1.readFrontendTask)(project, args.taskId).catch(() => undefined);
+                if (!task)
+                    return (0, result_1.ok)("ngm_workflow_generate_delivery_report", (0, operation_result_1.blocked)("write", "low", safetyMessage, "task.json was not found; create the frontend task first"));
+                let result;
+                try {
+                    result = await (0, frontend_task_service_1.writeTaskMarkdown)(project, args.taskId, "delivery-report.md", markdown, "delivered");
+                }
+                catch (error) {
+                    return transitionBlocked("ngm_workflow_generate_delivery_report", safetyMessage, error);
+                }
+                return (0, result_1.ok)("ngm_workflow_generate_delivery_report", {
+                    operation: (0, operation_result_1.operation)("executed", "write", "low", safetyMessage),
+                    project,
+                    task: result.task,
+                    changedFiles: result.changedFiles,
+                });
+            },
+        },
+    ];
+}

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

@@ -0,0 +1 @@
+export { frontendWorkflowTools } from "./frontend-workflow.tools";

package/lib/tools/workflow/index.js

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

package/lib/tools/workspace-package.d.ts

@@ -0,0 +1,22 @@
+export type PackageJsonSummary = {
+    name?: string;
+    version?: string;
+    private?: boolean;
+    description?: string;
+    path: string;
+    packageJsonPath: string;
+    scripts: Record<string, string>;
+    engines: Record<string, unknown>;
+    dependencies: Record<string, string>;
+    devDependencies: Record<string, string>;
+    peerDependencies: Record<string, string>;
+    workspaces?: unknown;
+    bin?: unknown;
+    main?: string;
+    types?: string;
+    exports?: unknown;
+};
+export declare function toRelativeWorkspacePath(workspaceRoot: string, filePath: string): string;
+export declare function readPackageJsonSummary(workspaceRoot: string, packageDir: string): Promise<PackageJsonSummary>;
+export declare function readOptionalPackageJsonSummary(workspaceRoot: string, packageDir: string): Promise<PackageJsonSummary | null>;
+export declare function listKnownWorkspacePackages(workspaceRoot: string): Promise<PackageJsonSummary[]>;