brakit 0.8.5 → 0.8.7

package/dist/mcp/server.js

@@ -51,7 +51,7 @@ var MAX_DISCOVERY_DEPTH = 5;
 var MAX_TIMELINE_EVENTS = 20;
 var MAX_RESOLVED_DISPLAY = 5;
 var ENRICHMENT_SEVERITY_FILTER = ["critical", "warning"];
-var MCP_SERVER_VERSION = "0.8.5";
+var MCP_SERVER_VERSION = "0.8.7";
 
 // src/mcp/client.ts
 var BrakitClient = class {
@@ -67,11 +67,11 @@ var BrakitClient = class {
     if (params?.offset) url.searchParams.set("offset", String(params.offset));
     return this.fetchJson(url);
   }
-  async getSecurityFindings() {
-    return this.fetchJson(`${this.baseUrl}${DASHBOARD_API_SECURITY}`);
-  }
-  async getInsights() {
-    return this.fetchJson(`${this.baseUrl}${DASHBOARD_API_INSIGHTS}`);
+  async getIssues(params) {
+    const url = new URL(`${this.baseUrl}${DASHBOARD_API_INSIGHTS}`);
+    if (params?.state) url.searchParams.set("state", params.state);
+    if (params?.category) url.searchParams.set("category", params.category);
+    return this.fetchJson(url);
   }
   async getQueries(requestId) {
     const url = new URL(`${this.baseUrl}${DASHBOARD_API_QUERIES}`);
@@ -145,7 +145,10 @@ import { readFile, readdir, stat } from "fs/promises";
 import { resolve, dirname } from "path";
 
 // src/constants/limits.ts
-var FINDING_ID_HASH_LENGTH = 16;
+var ISSUE_PRUNE_TTL_MS = 10 * 60 * 1e3;
+
+// src/constants/thresholds.ts
+var STALE_ISSUE_TTL_MS = 30 * 60 * 1e3;
 
 // src/constants/metrics.ts
 var PORT_FILE = ".brakit/port";
@@ -156,7 +159,7 @@ var PORT_MIN = 1;
 var PORT_MAX = 65535;
 
 // src/constants/lifecycle.ts
-var VALID_FINDING_STATES = /* @__PURE__ */ new Set(["open", "fixing", "resolved"]);
+var VALID_ISSUE_STATES = /* @__PURE__ */ new Set(["open", "fixing", "resolved", "stale", "regressed"]);
 var VALID_AI_FIX_STATUSES = /* @__PURE__ */ new Set(["fixed", "wont_fix"]);
 var VALID_SECURITY_SEVERITIES = /* @__PURE__ */ new Set(["critical", "warning"]);
 
@@ -241,13 +244,6 @@ async function waitForBrakit(cwd, timeoutMs = 1e4, pollMs = DISCOVERY_POLL_INTER
   );
 }
 
-// src/store/finding-id.ts
-import { createHash } from "crypto";
-function computeInsightId(type, endpoint, desc) {
-  const key = `${type}:${endpoint}:${desc}`;
-  return createHash("sha256").update(key).digest("hex").slice(0, FINDING_ID_HASH_LENGTH);
-}
-
 // src/utils/endpoint.ts
 function parseEndpointKey(endpoint) {
   const spaceIdx = endpoint.indexOf(" ");
@@ -259,14 +255,16 @@ function parseEndpointKey(endpoint) {
 
 // src/mcp/enrichment.ts
 async function enrichFindings(client) {
-  const [securityData, insightsData] = await Promise.all([
-    client.getSecurityFindings(),
-    client.getInsights()
-  ]);
+  const issuesData = await client.getIssues();
+  const issues = issuesData.issues.filter(
+    (si) => si.state !== "resolved" && si.state !== "stale"
+  );
   const contexts = await Promise.all(
-    securityData.findings.map(async (sf) => {
+    issues.map(async (si) => {
+      const endpoint = si.issue.endpoint;
+      if (!endpoint) return si.issue.detail ?? "";
       try {
-        const { path } = parseEndpointKey(sf.finding.endpoint);
+        const { path } = parseEndpointKey(endpoint);
         const reqData = await client.getRequests({ search: path, limit: 1 });
         if (reqData.requests.length > 0) {
           const req = reqData.requests[0];
@@ -280,38 +278,22 @@ async function enrichFindings(client) {
       } catch {
         return "(context unavailable)";
       }
-      return "";
+      return si.issue.detail ?? "";
     })
   );
-  const enriched = securityData.findings.map((sf, i) => {
-    const f = sf.finding;
-    return {
-      findingId: sf.findingId,
-      severity: f.severity,
-      title: f.title,
-      endpoint: f.endpoint,
-      description: f.desc,
-      hint: f.hint,
-      occurrences: f.count,
-      context: contexts[i],
-      aiStatus: sf.aiStatus,
-      aiNotes: sf.aiNotes
-    };
-  });
-  for (const si of insightsData.insights) {
-    if (si.state === "resolved") continue;
-    const i = si.insight;
-    if (!ENRICHMENT_SEVERITY_FILTER.includes(i.severity)) continue;
-    const endpoint = i.nav ?? "global";
+  const enriched = [];
+  for (let i = 0; i < issues.length; i++) {
+    const si = issues[i];
+    if (!ENRICHMENT_SEVERITY_FILTER.includes(si.issue.severity)) continue;
     enriched.push({
-      findingId: computeInsightId(i.type, endpoint, i.desc),
-      severity: i.severity,
-      title: i.title,
-      endpoint,
-      description: i.desc,
-      hint: i.hint,
-      occurrences: 1,
-      context: i.detail ?? "",
+      findingId: si.issueId,
+      severity: si.issue.severity,
+      title: si.issue.title,
+      endpoint: si.issue.endpoint ?? "global",
+      description: si.issue.desc,
+      hint: si.issue.hint,
+      occurrences: si.occurrences,
+      context: contexts[i],
       aiStatus: si.aiStatus,
       aiNotes: si.aiNotes
     });
@@ -370,8 +352,8 @@ async function buildRequestDetail(client, req) {
 function isNonEmptyString(val) {
   return typeof val === "string" && val.trim().length > 0;
 }
-function isValidFindingState(val) {
-  return typeof val === "string" && VALID_FINDING_STATES.has(val);
+function isValidIssueState(val) {
+  return typeof val === "string" && VALID_ISSUE_STATES.has(val);
 }
 function isValidAiFixStatus(val) {
   return typeof val === "string" && VALID_AI_FIX_STATUSES.has(val);
@@ -391,8 +373,8 @@ var getFindings = {
       },
       state: {
         type: "string",
-        enum: ["open", "fixing", "resolved"],
-        description: "Filter by finding state (from finding lifecycle)"
+        enum: ["open", "fixing", "resolved", "stale", "regressed"],
+        description: "Filter by issue state"
       }
     }
   },
@@ -402,17 +384,17 @@ var getFindings = {
     if (severity && !VALID_SECURITY_SEVERITIES.has(severity)) {
       return { content: [{ type: "text", text: `Invalid severity "${severity}". Use: critical, warning.` }], isError: true };
     }
-    if (state && !isValidFindingState(state)) {
-      return { content: [{ type: "text", text: `Invalid state "${state}". Use: open, fixing, resolved.` }], isError: true };
+    if (state && !isValidIssueState(state)) {
+      return { content: [{ type: "text", text: `Invalid state "${state}". Use: open, fixing, resolved, stale, regressed.` }], isError: true };
     }
     let findings = await enrichFindings(client);
     if (severity) {
       findings = findings.filter((f) => f.severity === severity);
     }
     if (state) {
-      const stateful = await client.getFindings(state);
-      const statefulIds = new Set(stateful.findings.map((f) => f.findingId));
-      findings = findings.filter((f) => statefulIds.has(f.findingId));
+      const issuesData = await client.getIssues({ state });
+      const issueIds = new Set(issuesData.issues.map((i) => i.issueId));
+      findings = findings.filter((f) => issueIds.has(f.findingId));
     }
     if (findings.length === 0) {
       return { content: [{ type: "text", text: "No findings detected. The application looks healthy." }] };
@@ -570,20 +552,21 @@ var verifyFix = {
     }
     if (findingId) {
       const data = await client.getFindings();
-      const finding = data.findings.find((f) => f.findingId === findingId);
+      const finding = data.findings.find((f) => f.issueId === findingId);
       if (!finding) {
         return {
           content: [{
             type: "text",
             text: `Finding ${findingId} not found. It may have already been resolved and cleaned up.`
-          }]
+          }],
+          isError: true
         };
       }
       if (finding.state === "resolved") {
         return {
           content: [{
             type: "text",
-            text: `RESOLVED: "${finding.finding.title}" on ${finding.finding.endpoint} is no longer detected. The fix worked.`
+            text: `RESOLVED: "${finding.issue.title}" on ${finding.issue.endpoint ?? "global"} is no longer detected. The fix worked.`
           }]
         };
       }
@@ -591,12 +574,12 @@ var verifyFix = {
         content: [{
           type: "text",
           text: [
-            `STILL PRESENT: "${finding.finding.title}" on ${finding.finding.endpoint}`,
+            `STILL PRESENT: "${finding.issue.title}" on ${finding.issue.endpoint ?? "global"}`,
             `  State: ${finding.state}`,
             `  Last seen: ${new Date(finding.lastSeenAt).toISOString()}`,
             `  Occurrences: ${finding.occurrences}`,
-            `  Issue: ${finding.finding.desc}`,
-            `  Hint: ${finding.finding.hint}`,
+            `  Issue: ${finding.issue.desc}`,
+            `  Hint: ${finding.issue.hint}`,
             "",
             "Make sure the user has triggered the endpoint again after the fix, so Brakit can re-analyze."
           ].join("\n")
@@ -606,7 +589,7 @@ var verifyFix = {
     if (endpoint) {
       const data = await client.getFindings();
       const endpointFindings = data.findings.filter(
-        (f) => f.finding.endpoint === endpoint || f.finding.endpoint.endsWith(` ${endpoint}`)
+        (f) => f.issue.endpoint === endpoint || f.issue.endpoint && f.issue.endpoint.endsWith(` ${endpoint}`)
       );
       if (endpointFindings.length === 0) {
         return {
@@ -616,7 +599,7 @@ var verifyFix = {
           }]
         };
       }
-      const open = endpointFindings.filter((f) => f.state === "open");
+      const open = endpointFindings.filter((f) => f.state === "open" || f.state === "regressed");
       const resolved = endpointFindings.filter((f) => f.state === "resolved");
       const lines = [
         `Endpoint: ${endpoint}`,
@@ -625,10 +608,10 @@ var verifyFix = {
         ""
       ];
       for (const f of open) {
-        lines.push(`  [${f.finding.severity}] ${f.finding.title}: ${f.finding.desc}`);
+        lines.push(`  [${f.issue.severity}] ${f.issue.title}: ${f.issue.desc}`);
       }
       for (const f of resolved) {
-        lines.push(`  [resolved] ${f.finding.title}`);
+        lines.push(`  [resolved] ${f.issue.title}`);
       }
       return { content: [{ type: "text", text: lines.join("\n") }] };
     }
@@ -636,7 +619,8 @@ var verifyFix = {
       content: [{
         type: "text",
         text: "Please provide either a finding_id or an endpoint to verify."
-      }]
+      }],
+      isError: true
     };
   }
 };
@@ -650,51 +634,52 @@ var getReport = {
     properties: {}
   },
   async handler(client, _args) {
-    const [findingsData, securityData, insightsData, metricsData] = await Promise.all([
-      client.getFindings(),
-      client.getSecurityFindings(),
-      client.getInsights(),
+    const [issuesData, metricsData] = await Promise.all([
+      client.getIssues(),
       client.getLiveMetrics()
     ]);
-    const findings = findingsData.findings;
-    const open = findings.filter((f) => f.state === "open");
-    const resolved = findings.filter((f) => f.state === "resolved");
-    const fixing = findings.filter((f) => f.state === "fixing");
-    const criticalOpen = open.filter((f) => f.finding.severity === "critical");
-    const warningOpen = open.filter((f) => f.finding.severity === "warning");
+    const issues = issuesData.issues;
+    const open = issues.filter((f) => f.state === "open" || f.state === "regressed");
+    const resolved = issues.filter((f) => f.state === "resolved");
+    const fixing = issues.filter((f) => f.state === "fixing");
+    const stale = issues.filter((f) => f.state === "stale");
+    const criticalOpen = open.filter((f) => f.issue.severity === "critical");
+    const warningOpen = open.filter((f) => f.issue.severity === "warning");
+    const securityIssues = issues.filter((f) => f.category === "security");
+    const perfIssues = issues.filter((f) => f.category === "performance");
     const totalRequests = metricsData.endpoints.reduce(
       (s, ep) => s + ep.summary.totalRequests,
       0
     );
-    const openInsightCount = insightsData.insights.filter((si) => si.state === "open").length;
     const lines = [
       "=== Brakit Report ===",
       "",
       `Endpoints observed: ${metricsData.endpoints.length}`,
       `Total requests captured: ${totalRequests}`,
-      `Active security rules: ${securityData.findings.length} finding(s)`,
-      `Performance insights: ${openInsightCount} open, ${insightsData.insights.length - openInsightCount} resolved`,
+      `Security issues: ${securityIssues.length}`,
+      `Performance issues: ${perfIssues.length}`,
       "",
-      "--- Finding Summary ---",
-      `Total: ${findings.length}`,
+      "--- Issue Summary ---",
+      `Total: ${issues.length}`,
       `  Open: ${open.length} (${criticalOpen.length} critical, ${warningOpen.length} warning)`,
       `  In progress: ${fixing.length}`,
-      `  Resolved: ${resolved.length}`
+      `  Resolved: ${resolved.length}`,
+      `  Stale: ${stale.length}`
     ];
     if (criticalOpen.length > 0) {
       lines.push("");
       lines.push("--- Critical Issues (fix first) ---");
       for (const f of criticalOpen) {
-        lines.push(`  [CRITICAL] ${f.finding.title} \u2014 ${f.finding.endpoint}`);
-        lines.push(`    ${f.finding.desc}`);
-        lines.push(`    Fix: ${f.finding.hint}`);
+        lines.push(`  [CRITICAL] ${f.issue.title} \u2014 ${f.issue.endpoint ?? "global"}`);
+        lines.push(`    ${f.issue.desc}`);
+        lines.push(`    Fix: ${f.issue.hint}`);
       }
     }
     if (resolved.length > 0) {
       lines.push("");
       lines.push("--- Recently Resolved ---");
       for (const f of resolved.slice(0, MAX_RESOLVED_DISPLAY)) {
-        lines.push(`  \u2713 ${f.finding.title} \u2014 ${f.finding.endpoint}`);
+        lines.push(`  \u2713 ${f.issue.title} \u2014 ${f.issue.endpoint ?? "global"}`);
       }
       if (resolved.length > MAX_RESOLVED_DISPLAY) {
         lines.push(`  ... and ${resolved.length - MAX_RESOLVED_DISPLAY} more`);