linear-ls 1.0.5 → 1.1.0

package/dist/server.js

@@ -1,17 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const sdk_1 = require("@linear/sdk");
 const node_1 = require("vscode-languageserver/node");
 const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
-const linear_1 = require("./linear");
 const connection = (0, node_1.createConnection)(node_1.ProposedFeatures.all);
 const documents = new node_1.TextDocuments(vscode_languageserver_textdocument_1.TextDocument);
-const teamKeys = new Set();
+const teams = new Map();
 const issues = new Map();
 const issuePositions = new Map();
+let client;
 connection.onInitialize(async () => {
-    await (0, linear_1.getTeamKeys)().then((keys) => {
-        keys.map((k) => {
-            teamKeys.add(k);
+    const apiKey = process.env.LINEAR_API_KEY;
+    if (!apiKey) {
+        connection.window.showWarningMessage("Linear API Key not found. Please set the LINEAR_API_KEY environment variable.");
+        return { capabilities: {} };
+    }
+    client = new sdk_1.LinearClient({ apiKey });
+    await client.teams().then((ts) => {
+        ts.nodes.forEach((t) => {
+            teams.set(t.key, t.id);
         });
     });
     const result = {
@@ -20,6 +27,13 @@ connection.onInitialize(async () => {
             codeActionProvider: {},
             hoverProvider: {},
             completionProvider: { resolveProvider: true },
+            semanticTokensProvider: {
+                legend: {
+                    tokenTypes: [node_1.SemanticTokenTypes.variable],
+                    tokenModifiers: [],
+                },
+                full: true,
+            },
         },
     };
     return result;
@@ -38,31 +52,35 @@ connection.onCodeAction((params) => {
         return [{ title: "Create Ticket" }];
     }
 });
+let documentChangeTimeout;
 documents.onDidChangeContent((change) => {
-    const text = change.document.getText();
-    const documentPositions = [];
-    Array.from(teamKeys)
-        .flatMap((prefix) => {
-        return Array.from(text.matchAll(new RegExp(`${prefix}-[0-9]*`, "g")));
-    })
-        .forEach((m) => {
-        const issueKey = m[0];
-        const positionStart = change.document.positionAt(m.index ?? 0);
-        const positionEnd = change.document.positionAt(issueKey.length + (m.index ?? 0));
-        // Write down that we've seen the issue, but don't
-        // fetch the definition just yet.
-        if (!issues.has(issueKey)) {
-            issues.set(issueKey, undefined);
-        }
-        documentPositions.push({
-            issueKey,
-            positionStart,
-            positionEnd,
-            offsetStart: change.document.offsetAt(positionStart),
-            offsetEnd: change.document.offsetAt(positionEnd),
+    clearTimeout(documentChangeTimeout);
+    documentChangeTimeout = setTimeout(() => {
+        const text = change.document.getText();
+        const documentPositions = [];
+        Array.from(teams.keys())
+            .flatMap((prefix) => {
+            return Array.from(text.matchAll(new RegExp(`${prefix}-[0-9]*`, "g")));
+        })
+            .forEach((m) => {
+            const issueKey = m[0];
+            const positionStart = change.document.positionAt(m.index ?? 0);
+            const positionEnd = change.document.positionAt(issueKey.length + (m.index ?? 0));
+            // Write down that we've seen the issue, but don't
+            // fetch the definition just yet.
+            if (!issues.has(issueKey)) {
+                issues.set(issueKey, undefined);
+            }
+            documentPositions.push({
+                issueKey,
+                positionStart,
+                positionEnd,
+                offsetStart: change.document.offsetAt(positionStart),
+                offsetEnd: change.document.offsetAt(positionEnd),
+            });
         });
-    });
-    issuePositions.set(change.document.uri, documentPositions);
+        issuePositions.set(change.document.uri, documentPositions);
+    }, 200);
 });
 connection.onHover(async (params) => {
     const documentPositions = issuePositions.get(params.textDocument.uri);
@@ -78,16 +96,23 @@ connection.onHover(async (params) => {
     if (!targetIssue) {
         return;
     }
-    const issue = await (0, linear_1.getIssueByKey)(targetIssue.issueKey);
+    const issueFromCache = issues.get(targetIssue.issueKey);
+    if (issueFromCache) {
+        return {
+            contents: issueFromCache.description ?? "Not available",
+        };
+    }
+    const issue = await client.issue(targetIssue.issueKey);
     if (!issue) {
         return;
     }
+    issues.set(targetIssue.issueKey, issue);
     return {
         contents: issue.description ?? "Not available",
     };
 });
 connection.onCompletion(async (params) => {
-    if (teamKeys.size === 0) {
+    if (teams.size === 0) {
         return [];
     }
     const document = documents.get(params.textDocument.uri);
@@ -98,7 +123,7 @@ connection.onCompletion(async (params) => {
         start: { line: params.position.line, character: 0 },
         end: { line: params.position.line, character: params.position.character },
     });
-    const lastMatch = Array.from(teamKeys)
+    const lastMatch = Array.from(teams.keys())
         .flatMap((prefix) => Array.from(lineToPosition.matchAll(new RegExp(`(${prefix})-(.*)`, "g"))))
         .at(-1);
     if (!lastMatch) {
@@ -108,24 +133,54 @@ connection.onCompletion(async (params) => {
     if (!teamKey || !searchString) {
         return [];
     }
-    const issues = await (0, linear_1.findIssuesByTitle)([teamKey], searchString);
-    if (issues === undefined) {
+    let issues;
+    try {
+        issues = await client.searchIssues(searchString, {
+            teamId: teams.get(teamKey),
+        });
+    }
+    catch (e) {
+        connection.console.error(`LLS: Error searching issues: ${e}`);
         return [];
     }
-    return issues.map((issue) => {
-        let label = `${issue.identifier}: ${issue.title}`;
+    return issues.nodes.map((i) => {
+        let label = `${i.identifier}: ${i.title}`;
         if (label.length > 60) {
-            label = label.substring(0, 60) + "...";
+            label = `${label.substring(0, 60)}...`;
         }
         return {
-            data: issue,
-            detail: issue.description ?? "Not available",
-            insertText: `[${issue.identifier}](${issue.url})`,
-            filterText: `${issue.team.key}-${issue.title}`,
+            data: i,
+            detail: i.description ?? "Not available",
+            insertText: `[${i.identifier}](${i.url})`,
             label,
             kind: node_1.CompletionItemKind.Reference,
         };
     });
 });
+connection.languages.semanticTokens.on((params) => {
+    const positions = issuePositions.get(params.textDocument.uri);
+    if (!positions) {
+        return { data: [] };
+    }
+    const builder = new node_1.SemanticTokensBuilder();
+    positions.sort((a, b) => {
+        if (a.positionStart.line !== b.positionStart.line) {
+            return a.positionStart.line - b.positionStart.line;
+        }
+        return a.positionStart.character - b.positionStart.character;
+    });
+    for (const p of positions) {
+        // Semantic tokens are assumed to be single-line. If a token ever spans multiple
+        // lines, its length must be calculated differently. For now, we ignore such ranges.
+        if (p.positionStart.line !== p.positionEnd.line) {
+            continue;
+        }
+        const length = p.positionEnd.character - p.positionStart.character;
+        builder.push(p.positionStart.line, p.positionStart.character, length, 0, // token type index (0 = variable, as defined in legend)
+        0 // token modifiers (none)
+        );
+    }
+    return builder.build();
+});
 documents.listen(connection);
 connection.listen();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linear-ls",
-  "version": "1.0.5",
+  "version": "1.1.0",
   "description": "Linear Language Server",
   "bin": "index.js",
   "main": "index.js",
@@ -18,36 +18,13 @@
     "index.js"
   ],
   "dependencies": {
-    "@urql/core": "^3.1.1",
-    "graphql": "^16.6.0",
-    "node-fetch": "^2.6.7",
-    "vscode-languageserver": "^8.0.2",
-    "vscode-languageserver-textdocument": "^1.0.8"
+    "@linear/sdk": "^68.1.0",
+    "vscode-languageserver": "^9.0.1",
+    "vscode-languageserver-textdocument": "^1.0.12"
   },
   "devDependencies": {
-    "@graphql-codegen/cli": "^3.0.0",
-    "@graphql-codegen/typescript": "^3.0.0",
-    "@graphql-codegen/typescript-operations": "^3.0.0",
-    "@types/node-fetch": "^2.6.2",
-    "@typescript-eslint/eslint-plugin": "^5.50.0",
-    "@typescript-eslint/parser": "^5.50.0",
-    "eslint": "^8.33.0",
-    "prettier": "^2.8.3",
-    "typescript": "^4.9.5"
-  },
-  "eslintConfig": {
-    "parser": "@typescript-eslint/parser",
-    "plugins": [
-      "@typescript-eslint"
-    ],
-    "extends": [
-      "eslint:recommended",
-      "plugin:@typescript-eslint/recommended"
-    ],
-    "rules": {
-      "@typescript-eslint/no-unused-vars": "error",
-      "@typescript-eslint/no-explicit-any": "error",
-      "@typescript-eslint/no-non-null-assertion": "error"
-    }
+    "@biomejs/biome": "^2.3.10",
+    "@types/node": "^23",
+    "typescript": "^5.9.3"
   }
 }

package/dist/linear.js

@@ -1,115 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findIssuesByTitle = exports.getIssueByKey = exports.getTeamKeys = void 0;
-const core_1 = require("@urql/core");
-const node_fetch_1 = __importDefault(require("node-fetch"));
-const client = (0, core_1.createClient)({
-    url: "https://api.linear.app/graphql",
-    requestPolicy: "cache-first",
-    exchanges: core_1.defaultExchanges,
-    fetch: node_fetch_1.default,
-    fetchOptions: {
-        headers: {
-            authorization: process.env.LINEAR_API_KEY,
-        },
-    },
-});
-async function getTeamKeys() {
-    const resp = await client
-        .query((0, core_1.gql) `
-        query FindTeamPrefixes {
-          teams {
-            nodes {
-              id
-              key
-            }
-          }
-        }
-      `, {})
-        .toPromise();
-    return resp.data?.teams.nodes.map((t) => t.key) ?? [];
-}
-exports.getTeamKeys = getTeamKeys;
-const issueFragment = (0, core_1.gql) `
-  fragment Issue on Issue {
-    id
-    identifier
-    title
-    description
-    url
-    team {
-      id
-      key
-    }
-  }
-`;
-async function getIssueByKey(key) {
-    const components = key.split("-");
-    const teamKey = components[0];
-    if (teamKey?.length !== 3) {
-        return;
-    }
-    const issueNumber = Number(components[1]);
-    if (!Number.isInteger(issueNumber)) {
-        return;
-    }
-    const resp = await client
-        .query((0, core_1.gql) `
-        query GetIssueByKey($filter: IssueFilter!) {
-          issues(filter: $filter) {
-            nodes {
-              ...Issue
-            }
-          }
-        }
-        ${issueFragment}
-      `, {
-        filter: {
-            team: { key: { eqIgnoreCase: teamKey } },
-            number: { eq: issueNumber },
-        },
-    })
-        .toPromise();
-    return resp.data?.issues?.nodes[0];
-}
-exports.getIssueByKey = getIssueByKey;
-async function findIssuesByTitle(teamKeys, issueTitle) {
-    const resp = await client
-        .query((0, core_1.gql) `
-        query FindIssuesByTitle(
-          $teamFilter: TeamFilter!
-          $issueFilter: IssueFilter!
-        ) {
-          teams(filter: $teamFilter) {
-            nodes {
-              id
-              issues(filter: $issueFilter) {
-                nodes {
-                  ...Issue
-                }
-              }
-            }
-          }
-        }
-        ${issueFragment}
-      `, {
-        teamFilter: {
-            or: teamKeys.map((tk) => ({
-                key: {
-                    containsIgnoreCase: tk,
-                },
-            })),
-        },
-        issueFilter: {
-            title: {
-                containsIgnoreCase: issueTitle,
-            },
-        },
-    })
-        .toPromise();
-    return resp.data?.teams.nodes.flatMap((team) => team.issues.nodes);
-}
-exports.findIssuesByTitle = findIssuesByTitle;

package/dist/types.generated.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });