@meltstudio/meltctl 4.93.2 → 4.95.0

package/dist/index.js

@@ -14,7 +14,7 @@ var CLI_VERSION;
 var init_version = __esm({
   "src/utils/version.ts"() {
     "use strict";
-    CLI_VERSION = "4.93.2";
+    CLI_VERSION = "4.95.0";
   }
 });
 
@@ -928,6 +928,17 @@ function createPmResource(config) {
     async runProjectAudit(projectId) {
       const res = await apiFetch(config, `/pm/project-audit/run/${projectId}`, { method: "POST" });
       return unwrap("run project audit", res);
+    },
+    /**
+     * Composite project-health snapshot — wraps every dimension that goes
+     * into the dashboard's health-score for one project (audit freshness,
+     * findings, board health, plan recency, activity, standup compliance,
+     * tickets) into a single response. Powers the `get_project_health`
+     * MCP tool.
+     */
+    async getProjectHealth(projectId) {
+      const res = await apiFetch(config, `/pm/project-health/${projectId}`);
+      return unwrap("get project health", res);
     }
   };
 }
@@ -2567,6 +2578,10 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z as z22 } from "zod";
 import { z as z3 } from "zod";
 import { z as z4 } from "zod";
+import { z as z5 } from "zod";
+import { z as z6 } from "zod";
+import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 function createAuditsResource2(config) {
   return {
     async submit(input3) {
@@ -3203,6 +3218,17 @@ function createPmResource2(config) {
     async runProjectAudit(projectId) {
       const res = await apiFetch2(config, `/pm/project-audit/run/${projectId}`, { method: "POST" });
       return unwrap2("run project audit", res);
+    },
+    /**
+     * Composite project-health snapshot — wraps every dimension that goes
+     * into the dashboard's health-score for one project (audit freshness,
+     * findings, board health, plan recency, activity, standup compliance,
+     * tickets) into a single response. Powers the `get_project_health`
+     * MCP tool.
+     */
+    async getProjectHealth(projectId) {
+      const res = await apiFetch2(config, `/pm/project-health/${projectId}`);
+      return unwrap2("get project health", res);
     }
   };
 }
@@ -3511,6 +3537,199 @@ function registerFeatureTools(server, client) {
     (args) => createFeature(client, args)
   );
 }
+var FLAG_STATUS_VALUES = ["open", "resolved", "dismissed", "all"];
+async function listAuditFlags(client, input3) {
+  return safe(() => client.pm.listAuditFlags(input3.projectId, input3.status ?? "open"));
+}
+async function dismissAuditFlag(client, input3) {
+  return safe(() => client.pm.dismissAuditFlag(input3.flagId, input3.reason));
+}
+async function getAuditCatalog(client) {
+  return safe(() => client.pm.getAuditCatalog());
+}
+async function runProjectAudit(client, input3) {
+  return safe(() => client.pm.runProjectAudit(input3.projectId));
+}
+var listAuditFlagsInputSchema = z5.object({
+  projectId: z5.number().int().positive(),
+  status: z5.enum(FLAG_STATUS_VALUES).optional()
+});
+var dismissAuditFlagInputSchema = z5.object({
+  flagId: z5.string().uuid(),
+  reason: z5.string().min(1)
+});
+function registerAuditTools(server, client) {
+  server.registerTool(
+    "list_audit_flags",
+    {
+      title: "List project audit flags",
+      description: "Lists audit flags the nightly cron has raised for a project. Each entry pairs the flag (id, severity, evidence, entity it points at, first/last seen, occurrence count, dismissed-by/reason if applicable) with its catalog entry (human-readable title + description + rule type). Default status='open'; pass 'all' to include resolved + dismissed for context.",
+      inputSchema: {
+        projectId: z5.number().int().positive(),
+        status: z5.enum(FLAG_STATUS_VALUES).optional().describe(
+          "Default 'open'. 'resolved' = fixed (flag no longer tripping on latest run). 'dismissed' = PM marked intentionally accepted. 'all' = every flag ever raised on this project."
+        )
+      }
+    },
+    (args) => listAuditFlags(client, args)
+  );
+  server.registerTool(
+    "get_audit_catalog",
+    {
+      title: "Get audit catalog",
+      description: "Returns every audit rule the system knows about (code, category, title, description, severity, rubric version). Use this to explain to a PM what a specific flag means, or to enumerate what kinds of things we audit for. Catalog is read-only \u2014 new entries land via migration.",
+      inputSchema: {}
+    },
+    () => getAuditCatalog(client)
+  );
+  server.registerTool(
+    "dismiss_audit_flag",
+    {
+      title: "Dismiss audit flag",
+      description: "Marks an audit flag as intentionally dismissed with a reason. Use when the PM has reviewed the flag and decided it's a false positive, out of scope, or an accepted trade-off. The reason is stored on the flag + visible in the audit trail; dismissals show up again the next time the flag re-fires unless the underlying rule is retired. This is a write \u2014 confirm with the PM before calling.",
+      inputSchema: {
+        flagId: z5.string().uuid(),
+        reason: z5.string().min(1).describe(
+          "Why this flag is being dismissed. Stored verbatim and shown in the audit trail."
+        )
+      }
+    },
+    (args) => dismissAuditFlag(client, args)
+  );
+  server.registerTool(
+    "run_project_audit",
+    {
+      title: "Run project audit now",
+      description: "Triggers an immediate audit run for a single project (same checks the nightly cron performs). Returns {fired, resolved, checkErrors}: how many new flags raised, how many existing flags cleared, and any per-check errors. Useful after a PM fixes something and wants to verify it cleared without waiting for tomorrow's cron.",
+      inputSchema: {
+        projectId: z5.number().int().positive()
+      }
+    },
+    (args) => runProjectAudit(client, args)
+  );
+}
+async function listPlans(client, input3 = {}) {
+  return safe(() => client.plans.list(input3));
+}
+async function getPlan(client, input3) {
+  return safe(() => client.plans.get(input3.planId));
+}
+var listPlansInputSchema = z6.object({
+  projectId: z6.number().int().positive().optional(),
+  status: z6.string().optional(),
+  author: z6.string().optional(),
+  ticket: z6.string().optional(),
+  repository: z6.string().optional(),
+  limit: z6.number().int().positive().max(200).optional()
+});
+function registerPlanTools(server, client) {
+  server.registerTool(
+    "list_plans",
+    {
+      title: "List plans",
+      description: "Lists recent dev-submitted plans (list view \u2014 no plan content). Each entry has id, project, repository, author email, branch, commit, ticket id, status, and the aggregate rubric score if scored. Filterable by projectId, status, author (email), ticket id, repository. Defaults to no filters; pass `limit` to cap the return size. Use `get_plan` to read a plan's full markdown content.",
+      inputSchema: {
+        projectId: z6.number().int().positive().optional().describe("Strapi project id from list_projects. Omit to list across all projects."),
+        status: z6.string().optional().describe("Common values: 'submitted', 'in_review', 'completed'."),
+        author: z6.string().optional().describe("Filter to one author's plans (e.g. 'dev@meltstudio.co')."),
+        ticket: z6.string().optional().describe(
+          "Filter to one ticket id (e.g. 'SD-562'). Useful for finding the plan tied to a specific bit of work."
+        ),
+        repository: z6.string().optional().describe("Filter to one repo path (e.g. 'MeltStudio/mc-backend')."),
+        limit: z6.number().int().positive().max(200).optional().describe("Cap the return size. Default is whatever the API returns (typically 50).")
+      }
+    },
+    (args) => listPlans(client, args)
+  );
+  server.registerTool(
+    "get_plan",
+    {
+      title: "Get plan",
+      description: "Returns one plan's full detail including the markdown `content`, `scoreSummary` (per-rubric-dimension scoring output), and any metadata the dev submitted. Use this after `list_plans` when the agent needs to read what the plan actually says.",
+      inputSchema: {
+        planId: z6.string().uuid()
+      }
+    },
+    (args) => getPlan(client, args)
+  );
+}
+async function listBoardAudits(client, input3 = {}) {
+  return safe(() => client.boardAudits.list(input3));
+}
+async function getBoardAudit(client, input3) {
+  return safe(() => client.boardAudits.get(input3.auditId));
+}
+async function listLatestBoardAudits(client) {
+  return safe(() => client.boardAudits.getLatestByProject());
+}
+async function getBoardAuditCatalog(client) {
+  return safe(() => client.boardAudits.getCatalog());
+}
+var listBoardAuditsInputSchema = z7.object({
+  projectId: z7.number().int().positive().optional(),
+  limit: z7.number().int().positive().max(200).optional()
+});
+function registerBoardAuditTools(server, client) {
+  server.registerTool(
+    "list_board_audits",
+    {
+      title: "List board audits",
+      description: "Lists recent board-hygiene audits. Each entry has id, projectId, the overall score, counts of open findings by severity, and the run timestamp. Filterable by projectId + limit. Use `get_board_audit` for the detailed finding list.",
+      inputSchema: {
+        projectId: z7.number().int().positive().optional().describe("Strapi project id. Omit to list across all accessible projects."),
+        limit: z7.number().int().positive().max(200).optional()
+      }
+    },
+    (args) => listBoardAudits(client, args)
+  );
+  server.registerTool(
+    "get_board_audit",
+    {
+      title: "Get board audit",
+      description: "Returns one board audit's full detail: overall score, per-finding breakdown (category, severity, entity reference, evidence), and the catalog metadata for each rule that fired. Use this to answer 'why did this project score low' questions.",
+      inputSchema: {
+        auditId: z7.string().uuid()
+      }
+    },
+    (args) => getBoardAudit(client, args)
+  );
+  server.registerTool(
+    "list_latest_board_audits",
+    {
+      title: "List latest board audits by project",
+      description: "Cross-project rollup: one entry per project showing its most recent board audit (score, severity-binned finding counts, run timestamp). Use this for questions like 'which of my projects has the worst board hygiene right now?' Cheaper than calling `list_board_audits` per project.",
+      inputSchema: {}
+    },
+    () => listLatestBoardAudits(client)
+  );
+  server.registerTool(
+    "get_board_audit_catalog",
+    {
+      title: "Get board-audit catalog",
+      description: "Returns every board-audit rule the system knows about (code, category, title, description, severity). Complements `get_audit_catalog` (which is for project-level flags); this one covers ticket-tracker hygiene checks.",
+      inputSchema: {}
+    },
+    () => getBoardAuditCatalog(client)
+  );
+}
+async function getProjectHealth(client, input3) {
+  return safe(() => client.pm.getProjectHealth(input3.projectId));
+}
+function registerProjectHealthTools(server, client) {
+  server.registerTool(
+    "get_project_health",
+    {
+      title: "Get project health",
+      description: "Composite read-only snapshot of one project's health: 0-100 score, audit-freshness numbers, findings (critical/high/missing/warning counts), board-audit aggregate + age, ticket counts (open/started/overdue), standup compliance (last 14 days), plan recency, last CLI activity. Use this for 'how's project X doing?' questions \u2014 it pulls in one round trip what would otherwise be 7+ separate tool calls. Score formula matches the dashboard's project cards.",
+      inputSchema: {
+        projectId: z8.number().int().positive().describe(
+          "Strapi project id from list_projects. The project must have at least one linked repository \u2014 otherwise the score is undefined and the tool returns 422."
+        )
+      }
+    },
+    (args) => getProjectHealth(client, args)
+  );
+}
 var VERSION = "0.0.0";
 function createMcpServer(client) {
   const server = new McpServer(
@@ -3520,6 +3739,10 @@ function createMcpServer(client) {
   registerProjectTools(server, client);
   registerPhaseTools(server, client);
   registerFeatureTools(server, client);
+  registerAuditTools(server, client);
+  registerPlanTools(server, client);
+  registerBoardAuditTools(server, client);
+  registerProjectHealthTools(server, client);
   return server;
 }
 async function startServer() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meltstudio/meltctl",
-  "version": "4.93.2",
+  "version": "4.95.0",
   "description": "AI-first development tools for teams - set up AGENTS.md, Claude Code, Cursor, and OpenCode standards",
   "main": "dist/index.js",
   "type": "module",