@redaksjon/brennpunkt 0.0.3 → 0.1.0

package/dist/mcp/server.js

@@ -1,11 +1,662 @@
 #!/usr/bin/env node
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { ListToolsRequestSchema, CallToolRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { existsSync, statSync, readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { c as calculateOverallCoverage, p as parseLcov, b as analyzeFile } from '../analyzer.js';
 
+const SCHEME = "brennpunkt";
+function parseUri(uri) {
+  if (!uri.startsWith(`${SCHEME}://`)) {
+    throw new Error(`Invalid URI scheme: ${uri}. Expected ${SCHEME}://`);
+  }
+  const withoutScheme = uri.substring(`${SCHEME}://`.length);
+  const [pathPart, queryPart] = withoutScheme.split("?");
+  const segments = pathPart.split("/");
+  if (segments.length === 0 || !segments[0]) {
+    throw new Error(`Invalid URI: ${uri}. No resource type specified.`);
+  }
+  const resourceType = segments[0];
+  const params = parseQueryParams(queryPart);
+  switch (resourceType) {
+    case "coverage":
+      return parseCoverageUri(segments, params);
+    case "file":
+      return parseFileUri(segments, params);
+    case "priorities":
+      return parsePrioritiesUri(params);
+    case "config":
+      return parseConfigUri(segments, params);
+    case "quick-wins":
+      return parseQuickWinsUri(params);
+    default:
+      throw new Error(`Unknown resource type: ${resourceType}`);
+  }
+}
+function parseQueryParams(queryPart) {
+  if (!queryPart) return {};
+  const params = {};
+  const pairs = queryPart.split("&");
+  for (const pair of pairs) {
+    const [key, value] = pair.split("=");
+    if (key && value !== void 0) {
+      params[decodeURIComponent(key)] = decodeURIComponent(value);
+    }
+  }
+  return params;
+}
+function parseCoverageUri(segments, params) {
+  const pathSegments = segments.slice(1);
+  let projectPath;
+  if (pathSegments.length === 0) {
+    throw new Error("Coverage URI requires project path");
+  }
+  if (pathSegments[0] === "") {
+    projectPath = "/" + pathSegments.slice(1).join("/");
+  } else {
+    projectPath = pathSegments.join("/");
+  }
+  if (!projectPath || projectPath === "/") {
+    throw new Error("Coverage URI requires project path");
+  }
+  return {
+    scheme: SCHEME,
+    resourceType: "coverage",
+    projectPath: decodeURIComponent(projectPath),
+    params
+  };
+}
+function parseFileUri(segments, params) {
+  if (segments.length < 3) {
+    throw new Error("File URI requires project path and file path");
+  }
+  const projectPath = decodeURIComponent(segments[1]);
+  const filePath = segments.slice(2).join("/");
+  return {
+    scheme: SCHEME,
+    resourceType: "file",
+    projectPath: decodeURIComponent(projectPath),
+    filePath: decodeURIComponent(filePath),
+    params
+  };
+}
+function parsePrioritiesUri(params) {
+  const projectPath = params.project;
+  if (!projectPath) {
+    throw new Error("Priorities URI requires project parameter");
+  }
+  return {
+    scheme: SCHEME,
+    resourceType: "priorities",
+    projectPath,
+    params
+  };
+}
+function parseConfigUri(segments, params) {
+  const pathSegments = segments.slice(1);
+  let projectPath;
+  if (pathSegments.length === 0) {
+    throw new Error("Config URI requires project path");
+  }
+  if (pathSegments[0] === "") {
+    projectPath = "/" + pathSegments.slice(1).join("/");
+  } else {
+    projectPath = pathSegments.join("/");
+  }
+  if (!projectPath || projectPath === "/") {
+    throw new Error("Config URI requires project path");
+  }
+  return {
+    scheme: SCHEME,
+    resourceType: "config",
+    projectPath: decodeURIComponent(projectPath),
+    params
+  };
+}
+function parseQuickWinsUri(params) {
+  const projectPath = params.project;
+  if (!projectPath) {
+    throw new Error("Quick wins URI requires project parameter");
+  }
+  return {
+    scheme: SCHEME,
+    resourceType: "quick-wins",
+    projectPath,
+    params
+  };
+}
+function buildCoverageUri(projectPath) {
+  return `${SCHEME}://coverage/${encodeURIComponent(projectPath).replace(/%2F/g, "/")}`;
+}
+function buildFileUri(projectPath, filePath) {
+  const encodedProject = encodeURIComponent(projectPath);
+  const encodedFile = encodeURIComponent(filePath).replace(/%2F/g, "/");
+  return `${SCHEME}://file/${encodedProject}/${encodedFile}`;
+}
+function buildPrioritiesUri(projectPath, options) {
+  const params = new URLSearchParams();
+  params.set("project", projectPath);
+  if (options?.top) params.set("top", String(options.top));
+  if (options?.minLines) params.set("minLines", String(options.minLines));
+  return `${SCHEME}://priorities?${params.toString()}`;
+}
+function buildConfigUri(projectPath) {
+  return `${SCHEME}://config/${encodeURIComponent(projectPath).replace(/%2F/g, "/")}`;
+}
+function buildQuickWinsUri(projectPath, maxLines) {
+  const params = new URLSearchParams();
+  params.set("project", projectPath);
+  if (maxLines) params.set("maxLines", String(maxLines));
+  return `${SCHEME}://quick-wins?${params.toString()}`;
+}
+
+const resourceTemplates = [
+  {
+    uriTemplate: "brennpunkt://coverage/{projectPath}",
+    name: "Coverage Report",
+    description: "Full coverage data for a project",
+    mimeType: "application/json"
+  },
+  {
+    uriTemplate: "brennpunkt://file/{projectPath}/{filePath}",
+    name: "File Coverage",
+    description: "Detailed coverage for a specific file",
+    mimeType: "application/json"
+  },
+  {
+    uriTemplate: "brennpunkt://priorities?project={projectPath}",
+    name: "Priority List",
+    description: "Files ranked by testing priority",
+    mimeType: "application/json"
+  },
+  {
+    uriTemplate: "brennpunkt://config/{projectPath}",
+    name: "Project Configuration",
+    description: "Brennpunkt configuration for a project",
+    mimeType: "application/json"
+  },
+  {
+    uriTemplate: "brennpunkt://quick-wins?project={projectPath}",
+    name: "Quick Wins",
+    description: "Small files with high impact potential",
+    mimeType: "application/json"
+  }
+];
+async function handleListResources() {
+  return {
+    resources: [],
+    resourceTemplates
+  };
+}
+async function handleReadResource(uri) {
+  const parsed = parseUri(uri);
+  switch (parsed.resourceType) {
+    case "coverage":
+      return readCoverageResource(parsed.projectPath);
+    case "file":
+      return readFileResource(parsed.projectPath, parsed.filePath);
+    case "priorities":
+      return readPrioritiesResource(parsed.projectPath, parsed.params);
+    case "config":
+      return readConfigResource(parsed.projectPath);
+    case "quick-wins":
+      return readQuickWinsResource(parsed.projectPath, parsed.params);
+    default:
+      throw new Error(`Unknown resource type: ${parsed.resourceType}`);
+  }
+}
+async function readCoverageResource(projectPath) {
+  const config = loadProjectConfig(projectPath);
+  const files = loadCoverage(projectPath, config);
+  const overall = calculateOverallCoverage(files);
+  const uri = buildCoverageUri(resolve(projectPath));
+  const data = {
+    projectPath: resolve(projectPath),
+    configUsed: existsSync(resolve(projectPath, "brennpunkt.yaml")) ? "brennpunkt.yaml" : "defaults",
+    overall: {
+      lines: overall.lines.coverage,
+      functions: overall.functions.coverage,
+      branches: overall.branches.coverage,
+      fileCount: overall.fileCount
+    },
+    files: files.map((f) => ({
+      file: f.file,
+      lines: {
+        hit: f.linesHit,
+        found: f.linesFound,
+        coverage: f.linesFound > 0 ? f.linesHit / f.linesFound * 100 : 100
+      },
+      functions: {
+        hit: f.functionsHit,
+        found: f.functionsFound,
+        coverage: f.functionsFound > 0 ? f.functionsHit / f.functionsFound * 100 : 100
+      },
+      branches: {
+        hit: f.branchesHit,
+        found: f.branchesFound,
+        coverage: f.branchesFound > 0 ? f.branchesHit / f.branchesFound * 100 : 100
+      }
+    }))
+  };
+  return {
+    uri,
+    mimeType: "application/json",
+    text: JSON.stringify(data, null, 2)
+  };
+}
+async function readFileResource(projectPath, filePath) {
+  const config = loadProjectConfig(projectPath);
+  const files = loadCoverage(projectPath, config);
+  const file = files.find(
+    (f) => f.file === filePath || f.file.endsWith(filePath) || filePath.endsWith(f.file)
+  );
+  if (!file) {
+    throw new Error(`File not found in coverage data: ${filePath}`);
+  }
+  const lineCov = file.linesFound > 0 ? file.linesHit / file.linesFound * 100 : 100;
+  const funcCov = file.functionsFound > 0 ? file.functionsHit / file.functionsFound * 100 : 100;
+  const branchCov = file.branchesFound > 0 ? file.branchesHit / file.branchesFound * 100 : 100;
+  const uri = buildFileUri(resolve(projectPath), filePath);
+  const data = {
+    projectPath: resolve(projectPath),
+    configUsed: existsSync(resolve(projectPath, "brennpunkt.yaml")) ? "brennpunkt.yaml" : "defaults",
+    file: file.file,
+    coverage: {
+      lines: {
+        covered: file.linesHit,
+        total: file.linesFound,
+        percentage: Math.round(lineCov * 10) / 10
+      },
+      functions: {
+        covered: file.functionsHit,
+        total: file.functionsFound,
+        percentage: Math.round(funcCov * 10) / 10
+      },
+      branches: {
+        covered: file.branchesHit,
+        total: file.branchesFound,
+        percentage: Math.round(branchCov * 10) / 10
+      }
+    },
+    uncovered: {
+      lines: file.linesFound - file.linesHit,
+      functions: file.functionsFound - file.functionsHit,
+      branches: file.branchesFound - file.branchesHit
+    },
+    suggestedFocus: generateSuggestedFocus(file)
+  };
+  return {
+    uri,
+    mimeType: "application/json",
+    text: JSON.stringify(data, null, 2)
+  };
+}
+async function readPrioritiesResource(projectPath, params) {
+  const config = loadProjectConfig(projectPath);
+  const files = loadCoverage(projectPath, config);
+  const top = params.top ? parseInt(params.top, 10) : config.top ?? 5;
+  const minLines = params.minLines ? parseInt(params.minLines, 10) : config.minLines ?? 10;
+  const weights = config.weights ?? DEFAULT_WEIGHTS;
+  const priorities = getPriorities(files, top, minLines, weights);
+  const overall = calculateOverallCoverage(files);
+  const uri = buildPrioritiesUri(resolve(projectPath), { top, minLines });
+  const data = {
+    projectPath: resolve(projectPath),
+    configUsed: existsSync(resolve(projectPath, "brennpunkt.yaml")) ? "brennpunkt.yaml" : "defaults",
+    overall: {
+      lines: overall.lines.coverage,
+      functions: overall.functions.coverage,
+      branches: overall.branches.coverage,
+      fileCount: overall.fileCount
+    },
+    priorities
+  };
+  return {
+    uri,
+    mimeType: "application/json",
+    text: JSON.stringify(data, null, 2)
+  };
+}
+async function readConfigResource(projectPath) {
+  const config = loadProjectConfig(projectPath);
+  const configPath = resolve(projectPath, "brennpunkt.yaml");
+  const hasConfig = existsSync(configPath);
+  const uri = buildConfigUri(resolve(projectPath));
+  const data = {
+    projectPath: resolve(projectPath),
+    configPath,
+    hasConfig,
+    config: {
+      coveragePath: config.coveragePath ?? "auto-detect",
+      weights: config.weights ?? DEFAULT_WEIGHTS,
+      minLines: config.minLines ?? 10,
+      top: config.top ?? 5
+    },
+    source: hasConfig ? "brennpunkt.yaml" : "defaults"
+  };
+  return {
+    uri,
+    mimeType: "application/json",
+    text: JSON.stringify(data, null, 2)
+  };
+}
+async function readQuickWinsResource(projectPath, params) {
+  const config = loadProjectConfig(projectPath);
+  const files = loadCoverage(projectPath, config);
+  const overall = calculateOverallCoverage(files);
+  const minLines = config.minLines ?? 10;
+  const maxLines = params.maxLines ? parseInt(params.maxLines, 10) : 100;
+  const quickWins = files.filter((f) => f.linesFound >= minLines && f.linesFound <= maxLines).map((f) => {
+    const uncoveredLines = f.linesFound - f.linesHit;
+    const potentialImpact = overall.lines.found > 0 ? uncoveredLines / overall.lines.found * 100 : 0;
+    const currentCoverage = f.linesFound > 0 ? f.linesHit / f.linesFound * 100 : 100;
+    return {
+      file: f.file,
+      linesTotal: f.linesFound,
+      uncoveredLines,
+      currentCoverage: Math.round(currentCoverage * 10) / 10,
+      potentialImpact: Math.round(potentialImpact * 100) / 100
+    };
+  }).filter((f) => f.uncoveredLines > 0).sort((a, b) => b.potentialImpact - a.potentialImpact).slice(0, 10);
+  const uri = buildQuickWinsUri(resolve(projectPath), maxLines);
+  const data = {
+    projectPath: resolve(projectPath),
+    configUsed: existsSync(resolve(projectPath, "brennpunkt.yaml")) ? "brennpunkt.yaml" : "defaults",
+    criteria: {
+      minLines,
+      maxLines
+    },
+    overall: {
+      lines: overall.lines.coverage
+    },
+    quickWins
+  };
+  return {
+    uri,
+    mimeType: "application/json",
+    text: JSON.stringify(data, null, 2)
+  };
+}
+
+const prompts = [
+  {
+    name: "improve_coverage",
+    description: "Complete workflow to improve test coverage to a target percentage. Analyzes current state, identifies gaps, estimates effort, and provides actionable plan.",
+    arguments: [
+      {
+        name: "projectPath",
+        description: "Absolute path to the project",
+        required: true
+      },
+      {
+        name: "targetPercentage",
+        description: "Target coverage percentage (default: 90)",
+        required: false
+      },
+      {
+        name: "focusMetric",
+        description: "Metric to focus on: lines, branches, or functions (default: lines)",
+        required: false
+      }
+    ]
+  },
+  {
+    name: "analyze_gaps",
+    description: "Understand why coverage is below target. Identifies patterns, problematic modules, and root causes.",
+    arguments: [
+      {
+        name: "projectPath",
+        description: "Absolute path to the project",
+        required: true
+      },
+      {
+        name: "targetPercentage",
+        description: "Target coverage to compare against (default: 90)",
+        required: false
+      }
+    ]
+  },
+  {
+    name: "quick_wins_workflow",
+    description: "Find fast paths to coverage improvement. Identifies small files with high impact, estimates effort and total improvement.",
+    arguments: [
+      {
+        name: "projectPath",
+        description: "Absolute path to the project",
+        required: true
+      },
+      {
+        name: "timeConstraint",
+        description: "Time available: quick (5 files), moderate (10 files), thorough (20 files)",
+        required: false
+      }
+    ]
+  },
+  {
+    name: "coverage_review",
+    description: "Code review focused on coverage gaps. Analyzes specific files, identifies untested functions/branches, suggests test cases.",
+    arguments: [
+      {
+        name: "projectPath",
+        description: "Absolute path to the project",
+        required: true
+      },
+      {
+        name: "filePattern",
+        description: "Filter to specific files (optional)",
+        required: false
+      }
+    ]
+  }
+];
+async function handleListPrompts() {
+  return { prompts };
+}
+async function handleGetPrompt(name, args) {
+  const prompt = prompts.find((p) => p.name === name);
+  if (!prompt) {
+    throw new Error(`Unknown prompt: ${name}`);
+  }
+  for (const arg of prompt.arguments || []) {
+    if (arg.required && !args[arg.name]) {
+      throw new Error(`Missing required argument: ${arg.name}`);
+    }
+  }
+  switch (name) {
+    case "improve_coverage":
+      return generateImproveCoveragePrompt(args);
+    case "analyze_gaps":
+      return generateAnalyzeGapsPrompt(args);
+    case "quick_wins_workflow":
+      return generateQuickWinsWorkflowPrompt(args);
+    case "coverage_review":
+      return generateCoverageReviewPrompt(args);
+    default:
+      throw new Error(`Prompt handler not implemented: ${name}`);
+  }
+}
+async function generateImproveCoveragePrompt(args) {
+  const projectPath = args.projectPath;
+  const target = parseFloat(args.targetPercentage || "90");
+  const metric = args.focusMetric || "lines";
+  const messages = [];
+  messages.push({
+    role: "user",
+    content: {
+      type: "text",
+      text: `I want to improve test coverage for ${projectPath} to ${target}% ${metric} coverage.`
+    }
+  });
+  let assistantText = `I'll help you improve test coverage to ${target}%.
+
+`;
+  assistantText += `**Workflow:**
+`;
+  assistantText += `1. Check current coverage: \`brennpunkt_coverage_summary\` with projectPath="${projectPath}"
+`;
+  assistantText += `2. Get priorities: \`brennpunkt_get_priorities\` to identify top files
+`;
+  assistantText += `3. Estimate impact: \`brennpunkt_estimate_impact\` to verify we'll hit ${target}%
+`;
+  assistantText += `4. Write tests for highest priority files
+
+`;
+  assistantText += `**Resources available:**
+`;
+  assistantText += `- Coverage data: ${buildCoverageUri(projectPath)}
+`;
+  assistantText += `- Priorities: ${buildPrioritiesUri(projectPath, { top: 5 })}
+
+`;
+  assistantText += `Let me start by checking your current coverage...`;
+  messages.push({
+    role: "assistant",
+    content: {
+      type: "text",
+      text: assistantText
+    }
+  });
+  return { messages };
+}
+async function generateAnalyzeGapsPrompt(args) {
+  const projectPath = args.projectPath;
+  const target = parseFloat(args.targetPercentage || "90");
+  const messages = [];
+  messages.push({
+    role: "user",
+    content: {
+      type: "text",
+      text: `Analyze coverage gaps in ${projectPath}. Why is coverage below ${target}%?`
+    }
+  });
+  let assistantText = `I'll analyze coverage gaps to understand the patterns.
+
+`;
+  assistantText += `**Analysis Plan:**
+`;
+  assistantText += `1. Get current coverage summary: \`brennpunkt_coverage_summary\`
+`;
+  assistantText += `2. Examine top priority files: \`brennpunkt_get_priorities\` with top=10
+`;
+  assistantText += `3. Look for patterns:
+`;
+  assistantText += `   - Are gaps in specific modules?
+`;
+  assistantText += `   - Common issue (branches, functions, lines)?
+`;
+  assistantText += `   - Error handling missing?
+`;
+  assistantText += `   - Edge cases untested?
+
+`;
+  assistantText += `**Resources:**
+`;
+  assistantText += `- Full coverage: ${buildCoverageUri(projectPath)}
+`;
+  assistantText += `- Priority analysis: ${buildPrioritiesUri(projectPath, { top: 10 })}
+
+`;
+  assistantText += `Let me examine the coverage data...`;
+  messages.push({
+    role: "assistant",
+    content: {
+      type: "text",
+      text: assistantText
+    }
+  });
+  return { messages };
+}
+async function generateQuickWinsWorkflowPrompt(args) {
+  const projectPath = args.projectPath;
+  const constraint = args.timeConstraint || "moderate";
+  const fileCount = constraint === "quick" ? 5 : constraint === "thorough" ? 20 : 10;
+  const messages = [];
+  messages.push({
+    role: "user",
+    content: {
+      type: "text",
+      text: `Find quick wins to improve coverage in ${projectPath}. I have ${constraint} time available.`
+    }
+  });
+  let assistantText = `I'll find ${fileCount} quick wins - small files with high impact.
+
+`;
+  assistantText += `**Strategy:**
+`;
+  assistantText += `1. Get quick wins: Use resource ${buildQuickWinsUri(projectPath, 100)}
+`;
+  assistantText += `2. Estimate total impact: \`brennpunkt_estimate_impact\` with identified files
+`;
+  assistantText += `3. Present in priority order with effort estimates
+`;
+  assistantText += `4. Suggest test approaches for each
+
+`;
+  assistantText += `**Criteria:**
+`;
+  assistantText += `- Small files (<100 lines)
+`;
+  assistantText += `- High impact potential
+`;
+  assistantText += `- Currently have coverage gaps
+
+`;
+  assistantText += `Let me identify the quick wins...`;
+  messages.push({
+    role: "assistant",
+    content: {
+      type: "text",
+      text: assistantText
+    }
+  });
+  return { messages };
+}
+async function generateCoverageReviewPrompt(args) {
+  const projectPath = args.projectPath;
+  const pattern = args.filePattern || "highest priority files";
+  const messages = [];
+  messages.push({
+    role: "user",
+    content: {
+      type: "text",
+      text: `Review coverage for ${pattern} in ${projectPath}. What tests should I write?`
+    }
+  });
+  let assistantText = `I'll perform a detailed coverage review.
+
+`;
+  assistantText += `**Review Process:**
+`;
+  assistantText += `1. Get priorities: \`brennpunkt_get_priorities\` to identify files
+`;
+  assistantText += `2. For each file:
+`;
+  assistantText += `   - Get details: \`brennpunkt_get_file_coverage\`
+`;
+  assistantText += `   - Identify untested functions/branches
+`;
+  assistantText += `   - Suggest specific test cases
+`;
+  assistantText += `3. Prioritize suggestions by impact
+
+`;
+  assistantText += `**Resources:**
+`;
+  assistantText += `- Priorities: ${buildPrioritiesUri(projectPath, { top: 5 })}
+
+`;
+  assistantText += `Let me start the review...`;
+  messages.push({
+    role: "assistant",
+    content: {
+      type: "text",
+      text: assistantText
+    }
+  });
+  return { messages };
+}
+
 const COVERAGE_SEARCH_PATHS = [
   "coverage/lcov.info",
   ".coverage/lcov.info",
@@ -430,13 +1081,20 @@ async function main() {
   const server = new Server(
     {
       name: "brennpunkt",
-      version: "0.0.1",
+      version: "0.1.0",
       // Server-level description for AI tools discovering this MCP server
       description: "Test coverage priority analyzer. Reads lcov.info coverage data (produced by Jest, Vitest, Mocha, c8, NYC, Karma, Playwright, or any lcov-compatible tool) and ranks files by testing priority. Use this to identify WHERE to focus testing efforts for maximum coverage impact WITHOUT running tests. Provides actionable insights: priority scores, coverage gaps, and specific suggestions for each file."
     },
     {
       capabilities: {
-        tools: {}
+        tools: {},
+        resources: {
+          subscribe: false,
+          listChanged: false
+        },
+        prompts: {
+          listChanged: false
+        }
       }
     }
   );
@@ -477,8 +1135,35 @@ async function main() {
       };
     }
   });
+  server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    return handleListResources();
+  });
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    try {
+      const contents = await handleReadResource(uri);
+      return { contents: [contents] };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to read resource ${uri}: ${message}`);
+    }
+  });
+  server.setRequestHandler(ListPromptsRequestSchema, async () => {
+    return handleListPrompts();
+  });
+  server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+      return handleGetPrompt(name, args || {});
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to get prompt ${name}: ${message}`);
+    }
+  });
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }
 main().catch(console.error);
+
+export { DEFAULT_CONFIG, DEFAULT_WEIGHTS, generateSuggestedFocus, getPriorities, loadCoverage, loadProjectConfig, validateProjectPath };
 //# sourceMappingURL=server.js.map