@knip/language-server 0.0.1

package/README.md

@@ -0,0 +1,136 @@
+# Knip Language Server
+
+## Knip
+
+Find unused files, dependencies, and exports in your JavaScript/TypeScript
+projects.
+
+- Website: [knip.dev][1]
+- GitHub repo: [webpro-nl/knip][2]
+- Follow [@webpro.nl on Bluesky][3] for updates
+- Blogpost: [Knip for Editors & Agents][4]
+- [Sponsor Knip][5]
+
+## Contents
+
+- [Configuration][6]
+- [Diagnostics][7]
+- [Code Actions][8]
+- [File Descriptor][9]
+  - [Annotations][10]
+  - [Export Hover][11]
+  - [Imports][12]
+  - [Exports][13]
+
+## Configuration
+
+Latest version of available settings: [types.d.ts][14]
+
+## Diagnostics
+
+Diagnostics should work out of the box.
+
+Most [Knip issue types][15] are translated to `Diagnostic` items with a
+`DiagnosticSeverity` and emitted using `this.connection.sendDiagnostics()`. Also
+see [diagnostics.js][16] for details.
+
+## Code Actions
+
+Code actions should work out of the box.
+
+Some issues/diagnostics have code actions available. Also see
+[code-actions.js][17] for details.
+
+## File Descriptor
+
+Clients request the `file` descriptor to get available data for a document by
+sending the `REQUEST_FILE_NODE` request, in short:
+
+```ts
+const file = await this.#client.sendRequest(REQUEST_FILE_NODE, {
+  uri: editor.document.uri.toString(),
+});
+```
+
+Type definition for `File`: [session/types.ts][18]
+
+The `file` descriptor can be used to implement features like [Annotations][10],
+[Export Hover][11], [Imports][12] and [Exports][13].
+
+### Annotations
+
+Annotations (aka "Code Lens" or "Inlay Hint") for exported identifiers can be
+implemented using data from the `file` descriptor.
+
+Example:
+
+- [registerCodeLensProvider][19]
+
+### Export Hover
+
+On hover of an export identifier, the `file` descriptor can be used to render
+import locations for the exported identifier.
+
+Optionally, code snippets can be searched for using the provided locations and
+mixed into the rendered list.
+
+Example:
+
+- [registerHoverProvider → getHoverContent][19]
+- [Collect hover snippets][20]
+- [Render export hover][21]
+
+### Imports
+
+The `file` desciptor can be used to display an overview of imports of a document
+with direct links to their definition location.
+
+Optionally, the client can implement:
+
+- Follow cursor between open document and highlight import in view
+- Show cyclic dependencies
+
+Example:
+
+- [setupTreeViews + refresh → getFileForTreeViews][19]
+- [Tree View Imports][22]
+
+### Exports
+
+The `file` desciptor can be used to display an overview of exports of a document
+with direct links to their usage locations.
+
+Optionally, the client can implement:
+
+- Follow cursor between open document and highlight export in view
+- Show contention: naming conflicts through re-exports
+- Show contention: branched/diamond-shaped re-export structures
+
+Example:
+
+- [setupTreeViews + refresh → getFileForTreeViews][19]
+- [Tree View Exports][23]
+
+[1]: https://knip.dev
+[2]: https://github.com/webpro-nl/knip
+[3]: https://bsky.app/profile/webpro.nl
+[4]: https://knip.dev/blog/for-editors-and-agents
+[5]: https://knip.dev/sponsors
+[6]: #configuration
+[7]: #diagnostics
+[8]: #code-actions
+[9]: #file-descriptor
+[10]: #annotations
+[11]: #export-hover
+[12]: #imports
+[13]: #exports
+[14]: ./src/types.d.ts
+[15]: https://knip.dev/reference/issue-types
+[16]: ./src/diagnostics.js
+[17]: ./src/code-actions.js
+[18]: ../knip/src/session/types.ts
+[19]: ../vscode-knip/src/index.js
+[20]: ../vscode-knip/src/collect-hover-snippets.js
+[21]: ../vscode-knip/src/render-export-hover.js
+[22]: ../vscode-knip/src/tree-view-imports.js
+[23]: ../vscode-knip/src/tree-view-exports.js

package/license

@@ -0,0 +1,15 @@
+ISC License (ISC)
+
+Copyright 2022-2025 Lars Kappert
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@knip/language-server",
+  "version": "0.0.1",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./src/types.d.ts",
+      "default": "./src/index.js"
+    },
+    "./constants": "./src/constants.js"
+  },
+  "dependencies": {
+    "vscode-languageserver": "^9.0.1",
+    "vscode-languageserver-textdocument": "^1.0.12",
+    "knip": "5.75.0"
+  },
+  "engines": {
+    "node": ">=18.18.0"
+  }
+}

package/src/code-actions.js

@@ -0,0 +1,121 @@
+import { DeleteFile, TextEdit } from 'vscode-languageserver/node.js';
+
+/**
+ * @import { WorkspaceEdit } from 'vscode-languageserver';
+ * @import { TextDocument } from 'vscode-languageserver-textdocument';
+ * @import { Issue } from 'knip/session';
+ */
+
+/**
+ * @param {TextDocument | undefined} document
+ * @param {string} uri
+ * @param {Issue} issue
+ * @returns {WorkspaceEdit | null}
+ */
+export const createRemoveExportEdit = (document, uri, issue) => {
+  try {
+    if (!document || !issue.fixes?.length) return null;
+
+    const edits = issue.fixes.map(([start, end]) => {
+      return TextEdit.del({ start: document.positionAt(start), end: document.positionAt(end) });
+    });
+
+    return { changes: { [uri]: edits } };
+  } catch (_error) {
+    return null;
+  }
+};
+
+/**
+ * @param {TextDocument | undefined} document
+ * @param {string} uri
+ * @param {Issue} issue
+ * @returns {WorkspaceEdit | null}
+ */
+export const createRemoveDependencyEdit = (document, uri, issue) => {
+  try {
+    if (!document || issue.line === undefined) return null;
+
+    const lineIndex = issue.line - 1;
+    const range = { start: { line: lineIndex, character: 0 }, end: { line: lineIndex + 1, character: 0 } };
+    const edits = [TextEdit.del(range)];
+
+    return { changes: { [uri]: edits } };
+  } catch (_error) {
+    return null;
+  }
+};
+
+/**
+ * @param {string} uri
+ * @returns {WorkspaceEdit | null}
+ */
+export const createDeleteFileEdit = uri => {
+  try {
+    return {
+      documentChanges: [DeleteFile.create(uri, { recursive: false, ignoreIfNotExists: true })],
+    };
+  } catch (_error) {
+    return null;
+  }
+};
+
+/**
+ *
+ * @param {TextDocument} document
+ * @param {Issue} issue
+ * @param {string} tag
+ */
+export function createAddJSDocTagEdit(document, issue, tag) {
+  try {
+    if (!document || issue.line === undefined) return null;
+
+    const lineIndex = issue.line - 1;
+    const lineText = document.getText({
+      start: { line: lineIndex, character: 0 },
+      end: { line: lineIndex + 1, character: 0 },
+    });
+    const indent = lineText.match(/^\s*/)?.[0] || '';
+
+    if (lineIndex > 0) {
+      const prevLineText = document.getText({
+        start: { line: lineIndex - 1, character: 0 },
+        end: { line: lineIndex, character: 0 },
+      });
+      const trimmedPrev = prevLineText.trim();
+
+      if (trimmedPrev.startsWith('/**') && trimmedPrev.endsWith('*/')) {
+        const content = trimmedPrev.slice(3, -2).trim();
+        const range = {
+          start: { line: lineIndex - 1, character: 0 },
+          end: { line: lineIndex - 1, character: prevLineText.length },
+        };
+
+        let multilineJSDoc = `${indent}/**\n${indent} * ${tag}`;
+        if (content) {
+          multilineJSDoc += `\n${indent} * ${content}`;
+        }
+        multilineJSDoc += `\n${indent} */`;
+
+        return [TextEdit.replace(range, multilineJSDoc)];
+      }
+
+      if (trimmedPrev.endsWith('*/')) {
+        for (let i = lineIndex - 2; i >= 0; i--) {
+          const text = document.getText({ start: { line: i, character: 0 }, end: { line: i + 1, character: 0 } });
+          if (text.trim().startsWith('/**')) {
+            const insertPosition = { line: i, character: text.trimEnd().length };
+            const tagLine = `\n${indent} * ${tag}`;
+            return [TextEdit.insert(insertPosition, tagLine)];
+          }
+        }
+      }
+    }
+
+    const jsdocComment = `${indent}/** ${tag} */\n`;
+    const insertPosition = { line: lineIndex, character: 0 };
+    return [TextEdit.insert(insertPosition, jsdocComment)];
+  } catch (_error) {
+    return null;
+  }
+}

package/src/constants.js

@@ -0,0 +1,13 @@
+export const DEFAULT_JSDOC_TAGS = ['@public', '@internal', '@lintignore'];
+
+export const REQUEST_START = 'knip.start';
+
+export const REQUEST_STOP = 'knip.stop';
+
+export const REQUEST_RESTART = 'knip.restart';
+
+export const REQUEST_FILE_NODE = 'knip.getFileNode';
+
+export const REQUEST_RESULTS = 'knip.getResults';
+
+export const SESSION_LOADING = 'session-loading';

package/src/diagnostics.js

@@ -0,0 +1,95 @@
+import { getIssuePrefix } from 'knip/session';
+import { DiagnosticSeverity, DiagnosticTag } from 'vscode-languageserver/node.js';
+
+/**
+ * @import { Diagnostic } from 'vscode-languageserver';
+ * @import { TextDocument } from 'vscode-languageserver-textdocument';
+ * @import { Config } from './types.js';
+ * @import { Issue, Rules } from 'knip/session';
+ */
+
+const SEVERITY = {
+  error: DiagnosticSeverity.Error,
+  warn: DiagnosticSeverity.Warning,
+  off: DiagnosticSeverity.Information,
+  hint: DiagnosticSeverity.Hint,
+};
+
+/**
+ * @param {Issue} issue
+ * @param {Rules} rules
+ * @param {Config} config
+ * @param {TextDocument} [document]
+ * @returns {Diagnostic}
+ */
+export const issueToDiagnostic = (issue, rules, config, document) => {
+  if (issue.type === 'files' && document) {
+    return {
+      severity: DiagnosticSeverity.Information,
+      range: {
+        start: { line: 0, character: 0 },
+        end: { line: 0, character: 1 },
+      },
+      message: formatMessage(issue),
+      source: 'knip',
+      code: issue.type,
+    };
+  }
+
+  /** @type {DiagnosticSeverity} */
+  let severity = SEVERITY[rules[issue.type]];
+
+  /** @type {DiagnosticTag[]} */
+  const tags = [];
+
+  if (issue.type === 'exports' && config.editor.exports.highlight.dimExports) {
+    severity = DiagnosticSeverity.Hint;
+    tags.push(DiagnosticTag.Unnecessary);
+  }
+
+  if (issue.type === 'types' && config.editor.exports.highlight.dimTypes) {
+    severity = DiagnosticSeverity.Hint;
+    tags.push(DiagnosticTag.Unnecessary);
+  }
+
+  const line = Math.max(0, (issue.line ?? 1) - 1);
+  const start = Math.max(0, (issue.col ?? 0) - 1);
+  let len = issue.symbol?.length ?? 1;
+
+  if (issue.symbol === 'default' && (issue.type === 'exports' || issue.type === 'types') && document) {
+    const lineText = document.getText({
+      start: { line, character: 0 },
+      end: { line: line + 1, character: 0 },
+    });
+
+    const match = /export\s+default\s+([A-Za-z0-9_$]+)/.exec(lineText);
+    if (match) {
+      const exportDefaultEnd = match.index + match[0].length;
+      len = exportDefaultEnd - start;
+    }
+  }
+
+  return {
+    severity,
+    range: {
+      start: { line, character: start },
+      end: { line, character: start + len },
+    },
+    message: formatMessage(issue),
+    source: 'knip',
+    code: issue.type,
+    tags: tags.length > 0 ? tags : undefined,
+  };
+};
+
+/** @param {Issue} issue */
+const formatMessage = issue => {
+  if (issue.type === 'files') return 'Unused file';
+  return getIssueDescription(issue);
+};
+
+/** @param {Issue} issue */
+const getIssueDescription = ({ type, symbol, symbols, parentSymbol }) => {
+  const symbolDescription = symbols ? `${symbols.map(s => s.symbol).join(', ')}` : symbol;
+  return `${getIssuePrefix(type)}: ${symbolDescription}${parentSymbol ? ` (${parentSymbol})` : ''}`;
+};

package/src/index.js

@@ -0,0 +1,3 @@
+import { LanguageServer } from './server.js';
+
+new LanguageServer();

package/src/server.js

@@ -0,0 +1,368 @@
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { createOptions, createSession, KNIP_CONFIG_LOCATIONS } from 'knip/session';
+import { FileChangeType, ProposedFeatures, TextDocuments } from 'vscode-languageserver';
+import { CodeActionKind, createConnection } from 'vscode-languageserver/node.js';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import {
+  createAddJSDocTagEdit,
+  createDeleteFileEdit,
+  createRemoveDependencyEdit,
+  createRemoveExportEdit,
+} from './code-actions.js';
+import {
+  DEFAULT_JSDOC_TAGS,
+  REQUEST_FILE_NODE,
+  REQUEST_RESTART,
+  REQUEST_RESULTS,
+  REQUEST_START,
+  REQUEST_STOP,
+  SESSION_LOADING,
+} from './constants.js';
+import { issueToDiagnostic } from './diagnostics.js';
+
+const RESTART_FOR = new Set(['package.json', ...KNIP_CONFIG_LOCATIONS]);
+
+/** @param {string} value */
+const toPosix = value => value.split(path.sep).join(path.posix.sep);
+
+/**
+ * @import { Issues, Rules } from 'knip/session';
+ * @import { Connection, Diagnostic, CodeAction } from 'vscode-languageserver';
+ * @import { CodeActionParams, DidChangeWatchedFilesParams } from 'vscode-languageserver';
+ * @import { Config, IssuesByUri } from './types.js';
+ *
+ * @typedef {import('knip/session').Session} Session
+ * @typedef {import('knip/session').File} File
+ */
+
+const FILE_CHANGE_TYPES = new Map([
+  [FileChangeType.Created, 'added'],
+  [FileChangeType.Deleted, 'deleted'],
+  [FileChangeType.Changed, 'modified'],
+]);
+
+const ISSUE_DESC = {
+  classMembers: 'class member',
+  enumMembers: 'enum member',
+  types: 'export keyword',
+  exports: 'export keyword',
+};
+
+export class LanguageServer {
+  /** @type {Connection} */
+  connection;
+
+  /** @type {undefined | string} */
+  cwd;
+
+  /** @type Set<string> */
+  published = new Set();
+
+  /** @type {undefined | Session} */
+  session;
+
+  /** @type {Rules}  */
+  rules = {};
+
+  /** @type {IssuesByUri} */
+  issuesByUri = new Map();
+
+  /** @type {Map<string, import('vscode-languageserver').Diagnostic[]>} */
+  cycleDiagnostics = new Map();
+
+  /** @type TextDocuments<TextDocument> */
+  documents;
+
+  constructor() {
+    this.connection = createConnection(ProposedFeatures.all);
+    this.documents = new TextDocuments(TextDocument);
+    this.setupHandlers();
+    this.documents.listen(this.connection);
+    this.connection.listen();
+  }
+
+  setupHandlers() {
+    this.connection.onInitialize(params => {
+      const uri = params.workspaceFolders?.[0]?.uri;
+
+      if (!uri) return { capabilities: {} };
+
+      this.cwd = fileURLToPath(uri);
+
+      const capabilities = {
+        codeActionProvider: {
+          codeActionKinds: [CodeActionKind.QuickFix],
+        },
+      };
+
+      return { capabilities };
+    });
+
+    this.connection.onInitialized(() => {});
+
+    this.connection.onRequest(REQUEST_START, () => this.start());
+
+    this.connection.onRequest(REQUEST_STOP, () => this.stop());
+
+    this.connection.onShutdown(() => this.stop());
+
+    this.connection.onRequest(REQUEST_RESTART, () => this.restart());
+
+    this.connection.onRequest(REQUEST_RESULTS, () => this.getResults());
+
+    this.connection.onRequest(REQUEST_FILE_NODE, async params => {
+      const config = await this.getConfig();
+      const isShowContention = config.exports?.contention?.enabled !== false;
+      return this.getFileDescriptor(fileURLToPath(params.uri), { isShowContention });
+    });
+
+    this.connection.onCodeAction(params => this.handleCodeAction(params));
+
+    this.connection.onDidChangeWatchedFiles(params => this.handleFileChanges(params));
+  }
+
+  /** @returns {Promise<Config>} */
+  async getConfig() {
+    return await this.connection.workspace.getConfiguration('knip');
+  }
+
+  /**
+   * @param {Issues} issues
+   * @param {Config} config
+   * @param {Rules} rules
+   * */
+  buildDiagnostics(issues, config, rules) {
+    /** @type {Map<string, Diagnostic[]>} */
+    const diagnostics = new Map();
+    this.issuesByUri.clear();
+
+    for (const issuesForType of Object.values(issues)) {
+      for (const issuesForFile of Object.values(issuesForType)) {
+        for (const issue of Object.values(issuesForFile)) {
+          const uri = pathToFileURL(issue.filePath).toString();
+          if (!diagnostics.has(uri)) diagnostics.set(uri, []);
+          const document = this.documents.get(uri);
+          const diagnostic = issueToDiagnostic(issue, rules, config, document);
+          diagnostics.get(uri)?.push(diagnostic);
+          if (!this.issuesByUri.has(uri)) this.issuesByUri.set(uri, new Map());
+          const key = `${diagnostic.range.start.line}:${diagnostic.range.start.character}`;
+          this.issuesByUri.get(uri)?.set(key, { issue, issueType: issue.type, diagnostic });
+        }
+      }
+    }
+    return diagnostics;
+  }
+
+  /** @param {Map<string, Diagnostic[]>} newDiags */
+  publishDiagnostics(newDiags) {
+    for (const [uri, diagnostics] of this.cycleDiagnostics) {
+      const existing = newDiags.get(uri) || [];
+      newDiags.set(uri, [...existing, ...diagnostics]);
+    }
+    for (const [uri, diagnostics] of newDiags) this.connection.sendDiagnostics({ uri, diagnostics });
+    for (const uri of this.published) if (!newDiags.has(uri)) this.connection.sendDiagnostics({ uri, diagnostics: [] });
+    this.published = new Set(newDiags.keys());
+  }
+
+  async start() {
+    if (this.session) return;
+
+    try {
+      const config = await this.getConfig();
+      if (!config?.enabled) return;
+
+      this.connection.console.log('Creating options');
+      const options = await createOptions({ cwd: this.cwd, isSession: true });
+      this.rules = options.rules;
+
+      this.connection.console.log('Building module graph...');
+      const start = Date.now();
+      const session = await createSession(options);
+      this.connection.console.log(`Finished building module graph (${Date.now() - start}ms)`);
+
+      this.session = session;
+      this.publishDiagnostics(this.buildDiagnostics(session.getIssues().issues, config, this.rules));
+    } catch (_error) {
+      this.connection.console.error(`Error: ${_error}`);
+    }
+  }
+
+  stop() {
+    this.session = undefined;
+    this.fileCache = undefined;
+    for (const uri of this.published) this.connection.sendDiagnostics({ uri, diagnostics: [] });
+    this.published.clear();
+  }
+
+  restart() {
+    this.stop();
+    this.start();
+  }
+
+  getResults() {
+    if (!this.session) return null;
+    return this.session.getResults();
+  }
+
+  /**
+   * @param {DidChangeWatchedFilesParams} params
+   * @return {Promise<void>}
+   */
+  async handleFileChanges(params) {
+    this.fileCache = undefined;
+    if (!this.session) return;
+
+    /** @type {{ type: "added" | "deleted" | "modified"; filePath: string }[]} */
+    const changes = [];
+    for (const change of params.changes) {
+      const filePath = fileURLToPath(change.uri);
+      if (RESTART_FOR.has(path.basename(change.uri))) return this.restart();
+      const type = FILE_CHANGE_TYPES.get(change.type);
+      if (!type) continue;
+      changes.push({ type, filePath });
+    }
+
+    const result = await this.session.handleFileChanges(changes);
+
+    if (result) {
+      this.connection.console.log(
+        `Module graph updated (${Math.floor(result.duration)}ms • ${(result.mem / 1024 / 1024).toFixed(2)}M)`
+      );
+    }
+
+    const config = await this.getConfig();
+    this.publishDiagnostics(this.buildDiagnostics(this.session.getIssues().issues, config, this.rules));
+  }
+
+  /**
+   * @param {string} filePath
+   * @param {{ isShowContention?: boolean }} [options]
+   * @returns {File | typeof SESSION_LOADING | undefined}
+   */
+  getFileDescriptor(filePath, options) {
+    if (!this.session) return SESSION_LOADING;
+    const relPath = toPosix(path.relative(this.cwd ?? process.cwd(), filePath));
+    if (this.fileCache?.filePath === relPath) return this.fileCache.file;
+    const startTime = performance.now();
+    const file = this.session.describeFile(relPath, options);
+    if (file) {
+      const duration = Math.round(performance.now() - startTime);
+      const mem = process.memoryUsage().heapUsed;
+      this.connection.console.log(
+        `Received file descriptor (${relPath} • ${duration}ms • ${(mem / 1024 / 1024).toFixed(2)}M)`
+      );
+      const m = file.metrics;
+      this.connection.console.log(
+        `  ↳ imports: ${Math.round(m.imports)}ms, exports: ${Math.round(m.exports)}ms, cycles: ${Math.round(m.cycles)}ms, contention: ${Math.round(m.contention)}ms`
+      );
+      this.fileCache = { filePath: relPath, file };
+      return file;
+    }
+    this.connection.console.log(`File not in project (${relPath})`);
+  }
+
+  /**
+   * @param {CodeActionParams} params
+   * @returns {Promise<CodeAction[]>}
+   */
+  async handleCodeAction(params) {
+    const config = await this.getConfig();
+    if (!config.editor.exports.quickfix.enabled) return [];
+
+    const uri = params.textDocument.uri;
+    const issuesForUri = this.issuesByUri.get(uri);
+    if (!issuesForUri) return [];
+    const document = this.documents.get(uri);
+    const jsdocTags = Array.isArray(config.editor.exports.quickfix.jsdocTags)
+      ? config.editor.exports.quickfix.jsdocTags
+      : DEFAULT_JSDOC_TAGS;
+
+    /** @type {CodeAction[]} */
+    const codeActions = [];
+
+    for (const diagnostic of params.context.diagnostics) {
+      if (diagnostic.source !== 'knip') continue;
+
+      const key = `${diagnostic.range.start.line}:${diagnostic.range.start.character}`;
+      const issuesForFile = issuesForUri.get(key);
+      if (!issuesForFile) continue;
+
+      const { issue, issueType } = issuesForFile;
+
+      if (
+        issueType === 'exports' ||
+        issueType === 'types' ||
+        issueType === 'classMembers' ||
+        issueType === 'enumMembers'
+      ) {
+        const removeExportEdit = createRemoveExportEdit(document, uri, issue);
+        if (!removeExportEdit) continue;
+        codeActions.push({
+          title: `Remove ${ISSUE_DESC[issueType]} (${issue.symbol})`,
+          kind: CodeActionKind.QuickFix,
+          diagnostics: [diagnostic],
+          edit: removeExportEdit,
+        });
+
+        if (document) {
+          for (const tag of jsdocTags) {
+            const jsdocEdit = createAddJSDocTagEdit(document, issue, tag);
+            if (!jsdocEdit) continue;
+            codeActions.push({
+              title: `Add ${tag} JSDoc tag`,
+              kind: CodeActionKind.QuickFix,
+              diagnostics: [diagnostic],
+              edit: { changes: { [uri]: jsdocEdit } },
+            });
+          }
+        }
+      }
+
+      if (issueType === 'dependencies' || issueType === 'devDependencies') {
+        const removeDependencyEdit = createRemoveDependencyEdit(document, uri, issue);
+        if (!removeDependencyEdit) continue;
+        codeActions.push({
+          title: `Remove dependency "${issue.symbol}"`,
+          kind: CodeActionKind.QuickFix,
+          diagnostics: [diagnostic],
+          edit: removeDependencyEdit,
+        });
+      }
+
+      if (issueType === 'unlisted') {
+        codeActions.push({
+          title: `Add '${issue.symbol}' to dependencies in package.json`,
+          kind: CodeActionKind.QuickFix,
+          diagnostics: [diagnostic],
+        });
+
+        codeActions.push({
+          title: `Add '${issue.symbol}' to devDependencies in package.json`,
+          kind: CodeActionKind.QuickFix,
+          diagnostics: [diagnostic],
+        });
+
+        codeActions.push({
+          title: `Add '@types/${issue.symbol}' to devDependencies in package.json`,
+          kind: CodeActionKind.QuickFix,
+          diagnostics: [diagnostic],
+        });
+      }
+
+      if (issueType === 'files') {
+        const deleteEdit = createDeleteFileEdit(uri);
+        if (deleteEdit) {
+          codeActions.push({
+            title: `Delete this file`,
+            kind: CodeActionKind.QuickFix,
+            diagnostics: [diagnostic],
+            edit: deleteEdit,
+          });
+        }
+      }
+    }
+
+    return codeActions;
+  }
+}

package/src/types.d.ts

@@ -0,0 +1,45 @@
+import type { Issue, IssueType } from 'knip/session';
+
+export type Config = {
+  enabled: boolean;
+  editor: {
+    exports: {
+      codelens: {
+        enabled: boolean;
+      };
+      hover: {
+        enabled: boolean;
+        includeImportLocationSnippet: boolean;
+        maxSnippets: number;
+        timeout: number;
+      };
+      quickfix: {
+        enabled: boolean;
+        jsdocTags?: string[];
+      };
+      highlight: {
+        dimExports: boolean;
+        dimTypes: boolean;
+      };
+    };
+  };
+  imports: {
+    enabled: boolean;
+  };
+  exports: {
+    enabled: boolean;
+    contention: {
+      enabled: boolean;
+    };
+  };
+};
+
+export type IssueForFile = {
+  issue: Issue;
+  issueType: IssueType;
+  diagnostic: Diagnostic;
+};
+
+export type IssuesForFile = Map<string, IssueForFile>;
+
+export type IssuesByUri = Map<string, IssuesForFile>;

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "checkJs": true,
+    "module": "nodenext",
+    "noEmit": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "target": "esnext"
+  }
+}