linear-ls 1.1.1 → 1.3.0

package/README.md

@@ -10,22 +10,14 @@ npm i -g linear-ls
 
 ### neovim
 
-If you use `lspconfig`, add the following:
-
 ```lua
-if not lspconfigconfigs.linear_ls then
-  lspconfigconfigs.linear_ls = {
-    default_config = {
-      cmd = { "linear-ls", "--stdio" },
-      filetypes = { "typescript" },
-      root_dir = function(fname)
-        return lspconfig.util.find_git_ancestor(fname)
-      end,
-    },
-}
-end
-lspconfig.lls.setup({
-  capabilities = capabilities,
+vim.lsp.config("linear-ls", {
+	cmd = { "linear-ls", "--stdio" },
+	filetypes = { "typescript" },
+})
+
+vim.lsp.enable({
+	"linear-ls",
 })
 ```
 
@@ -47,4 +39,6 @@ Typing team key, hyphen and search term (e.g. `EUC-thing`) triggers issue search
 
 ### Create Ticket from Text Selection
 
-TODO
+Select text in your editor and trigger the code action (e.g., `ga` in Neovim or `Cmd+.` in VS Code) to create a Linear issue. The selected text will be used as the issue title, and it will be replaced with a link to the created ticket in the format `[KEY-123](https://linear.app/...)`.
+
+_Note: The server currently uses the first available team it has access to._

package/dist/server.js

@@ -3,17 +3,51 @@ 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");
-// ENG-100
-const connection = (0, node_1.createConnection)(node_1.ProposedFeatures.all);
-const documents = new node_1.TextDocuments(vscode_languageserver_textdocument_1.TextDocument);
+const conn = (0, node_1.createConnection)(node_1.ProposedFeatures.all);
+const docs = new node_1.TextDocuments(vscode_languageserver_textdocument_1.TextDocument);
 const teams = new Map();
 const issues = new Map();
-const issuePositions = new Map();
+const positions = new Map();
 let client;
-connection.onInitialize(async () => {
+async function diagnostics(textDocument) {
+    if (!client) {
+        return;
+    }
+    const docPositions = positions.get(textDocument.uri);
+    if (!docPositions) {
+        return;
+    }
+    const diagnostics = [];
+    for (const p of docPositions) {
+        let issue = issues.get(p.issueKey);
+        if (!issue) {
+            issue = await client.issue(p.issueKey).catch(() => undefined);
+            if (issue)
+                issues.set(p.issueKey, issue);
+        }
+        if (issue?.completedAt) {
+            diagnostics.push({
+                severity: node_1.DiagnosticSeverity.Information,
+                range: { start: p.positionStart, end: p.positionEnd },
+                message: `${p.issueKey} is completed`,
+                source: "Linear",
+            });
+        }
+        else if (issue?.archivedAt) {
+            diagnostics.push({
+                severity: node_1.DiagnosticSeverity.Information,
+                range: { start: p.positionStart, end: p.positionEnd },
+                message: `${p.issueKey} is archived`,
+                source: "Linear",
+            });
+        }
+    }
+    conn.sendDiagnostics({ uri: textDocument.uri, diagnostics });
+}
+conn.onInitialize(async () => {
     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.");
+        conn.window.showWarningMessage("Linear API Key not found. Please set the LINEAR_API_KEY environment variable.");
         return { capabilities: {} };
     }
     client = new sdk_1.LinearClient({ apiKey });
@@ -22,10 +56,13 @@ connection.onInitialize(async () => {
             teams.set(t.key, t.id);
         });
     });
-    const result = {
+    return {
         capabilities: {
             textDocumentSync: node_1.TextDocumentSyncKind.Incremental,
             codeActionProvider: {},
+            executeCommandProvider: {
+                commands: ["linear-ls.createIssue", "linear-ls.openIssue"],
+            },
             hoverProvider: {},
             completionProvider: { resolveProvider: true },
             semanticTokensProvider: {
@@ -37,33 +74,124 @@ connection.onInitialize(async () => {
             },
         },
     };
-    return result;
 });
-connection.onCodeAction((params) => {
+conn.onCodeAction(async (params) => {
+    const actions = [];
     if (params.context.triggerKind === node_1.CodeActionTriggerKind.Invoked) {
-        const textDocument = documents.get(params.textDocument.uri);
-        if (!textDocument) {
+        const doc = docs.get(params.textDocument.uri);
+        if (doc) {
+            const text = doc.getText(params.range);
+            if (text) {
+                actions.push({
+                    title: "Create Issue from Selection",
+                    kind: node_1.CodeActionKind.RefactorRewrite,
+                    command: {
+                        command: "linear-ls.createIssue",
+                        title: "Create Issue",
+                        arguments: [params.textDocument.uri, params.range, text.trim()],
+                    },
+                });
+            }
+        }
+    }
+    const docPositions = positions.get(params.textDocument.uri);
+    for (const p of docPositions ?? []) {
+        if (p.positionStart.line === params.range.start.line) {
+            if (params.range.start.character >= p.positionStart.character &&
+                params.range.start.character <= p.positionEnd.character) {
+                let issue = issues.get(p.issueKey);
+                if (!issue) {
+                    issue = await client.issue(p.issueKey).catch(() => undefined);
+                    if (issue)
+                        issues.set(p.issueKey, issue);
+                }
+                if (issue?.url) {
+                    actions.push({
+                        title: `Open ${p.issueKey} in Linear`,
+                        kind: node_1.CodeActionKind.Empty,
+                        command: {
+                            command: "linear-ls.openIssue",
+                            title: "Open in Linear",
+                            arguments: [issue.url],
+                        },
+                    });
+                }
+            }
+        }
+    }
+    return actions;
+});
+conn.onExecuteCommand(async (params) => {
+    if (params.command === "linear-ls.openIssue") {
+        const [url] = params.arguments || [];
+        if (url) {
+            conn.window.showDocument({ uri: url, external: true });
+        }
+    }
+    if (params.command === "linear-ls.createTicket") {
+        const [uri, range, title] = params.arguments || [];
+        if (!uri || !range || !title) {
             return;
         }
-        const text = textDocument.getText(params.range);
-        if (!text) {
+        if (teams.size === 0) {
+            conn.window.showErrorMessage("No teams found. Please ensure you have access to at least one Linear team.");
             return;
         }
-        // TODO: Implement command to create ticket
-        return [{ title: "Create Ticket" }];
+        let teamId;
+        if (teams.size === 1) {
+            teamId = teams.values().next().value;
+        }
+        else {
+            const teamItems = Array.from(teams.keys()).map((key) => ({
+                title: key,
+            }));
+            const selected = await conn.window.showInformationMessage("Select a team for the new ticket:", ...teamItems);
+            if (selected) {
+                teamId = teams.get(selected.title);
+            }
+        }
+        if (!teamId) {
+            return;
+        }
+        try {
+            const issue = await client.createIssue({ teamId, title });
+            const createdIssue = await issue.issue;
+            if (createdIssue) {
+                const identifier = createdIssue.identifier;
+                const url = createdIssue.url;
+                const link = `[${identifier}](${url})`;
+                const edit = {
+                    changes: {
+                        [uri]: [
+                            {
+                                range: range,
+                                newText: link,
+                            },
+                        ],
+                    },
+                };
+                await conn.workspace.applyEdit(edit);
+            }
+        }
+        catch (e) {
+            conn.console.error(`Error creating issue: ${e}`);
+            conn.window.showErrorMessage(`Failed to create Linear issue: ${e}`);
+        }
     }
 });
 let documentChangeTimeout;
-documents.onDidChangeContent((change) => {
+docs.onDidChangeContent((change) => {
     clearTimeout(documentChangeTimeout);
-    documentChangeTimeout = setTimeout(() => {
+    documentChangeTimeout = setTimeout(async () => {
         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 teamKeys = Array.from(teams.keys());
+        if (teamKeys.length === 0) {
+            positions.set(change.document.uri, []);
+            return;
+        }
+        const regexp = new RegExp(`(${teamKeys.join("|")})-[0-9]*`, "g");
+        Array.from(text.matchAll(regexp)).forEach((m) => {
             const issueKey = m[0];
             const positionStart = change.document.positionAt(m.index ?? 0);
             const positionEnd = change.document.positionAt(issueKey.length + (m.index ?? 0));
@@ -80,43 +208,42 @@ documents.onDidChangeContent((change) => {
                 offsetEnd: change.document.offsetAt(positionEnd),
             });
         });
-        issuePositions.set(change.document.uri, documentPositions);
-    }, 200);
+        positions.set(change.document.uri, documentPositions);
+        await diagnostics(change.document);
+    }, 1000);
 });
-connection.onHover(async (params) => {
-    const documentPositions = issuePositions.get(params.textDocument.uri);
-    if (!documentPositions) {
+conn.onHover(async (params) => {
+    const docPositions = positions.get(params.textDocument.uri);
+    if (!docPositions) {
         return;
     }
-    const textDocument = documents.get(params.textDocument.uri);
-    if (!textDocument) {
+    const doc = docs.get(params.textDocument.uri);
+    if (!doc) {
         return;
     }
-    const cursorOffset = textDocument.offsetAt(params.position);
-    const targetIssue = documentPositions.find((dp) => dp.offsetStart <= cursorOffset && dp.offsetEnd > cursorOffset);
-    if (!targetIssue) {
+    const cursorOffset = doc.offsetAt(params.position);
+    const pos = docPositions.find((dp) => dp.offsetStart <= cursorOffset && dp.offsetEnd > cursorOffset);
+    if (!pos) {
         return;
     }
-    const issueFromCache = issues.get(targetIssue.issueKey);
-    if (issueFromCache) {
-        return {
-            contents: issueFromCache.description ?? "Not available",
-        };
+    let issue = issues.get(pos.issueKey);
+    if (!issue) {
+        issue = await client.issue(pos.issueKey).catch(() => undefined);
+        if (issue)
+            issues.set(pos.issueKey, issue);
     }
-    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) => {
+conn.onCompletion(async (params) => {
     if (teams.size === 0) {
         return [];
     }
-    const document = documents.get(params.textDocument.uri);
+    const document = docs.get(params.textDocument.uri);
     if (!document) {
         return [];
     }
@@ -141,7 +268,7 @@ connection.onCompletion(async (params) => {
         });
     }
     catch (e) {
-        connection.console.error(`LLS: Error searching issues: ${e}`);
+        conn.console.error(`LLS: Error searching issues: ${e}`);
         return [];
     }
     return issues.nodes.map((i) => {
@@ -158,30 +285,21 @@ connection.onCompletion(async (params) => {
         };
     });
 });
-connection.languages.semanticTokens.on((params) => {
-    const positions = issuePositions.get(params.textDocument.uri);
-    if (!positions) {
+conn.languages.semanticTokens.on((params) => {
+    const docPositions = positions.get(params.textDocument.uri);
+    if (!docPositions) {
         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.
+    for (const p of docPositions) {
         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)
-        );
+        0);
     }
     return builder.build();
 });
-documents.listen(connection);
-connection.listen();
+docs.listen(conn);
+conn.listen();

package/package.json

@@ -1,30 +1,30 @@
 {
-  "name": "linear-ls",
-  "version": "1.1.1",
-  "description": "Linear Language Server",
-  "bin": "index.js",
-  "main": "index.js",
-  "keywords": [
-    "lsp",
-    "linear",
-    "language",
-    "productivity"
-  ],
-  "repository": "https://github.com/wilhelmeek/linear-ls",
-  "author": "wilhelm <helm@hey.com>",
-  "license": "MIT",
-  "files": [
-    "dist/*.js",
-    "index.js"
-  ],
-  "dependencies": {
-    "@linear/sdk": "^68.1.0",
-    "vscode-languageserver": "^9.0.1",
-    "vscode-languageserver-textdocument": "^1.0.12"
-  },
-  "devDependencies": {
-    "@biomejs/biome": "^2.3.10",
-    "@types/node": "^23",
-    "typescript": "^5.9.3"
-  }
+	"name": "linear-ls",
+	"version": "1.3.0",
+	"description": "Linear Language Server",
+	"bin": "index.js",
+	"main": "index.js",
+	"keywords": [
+		"lsp",
+		"linear",
+		"language",
+		"productivity"
+	],
+	"repository": "https://github.com/wilhelmeek/linear-ls",
+	"author": "wilhelm <helm@hey.com>",
+	"license": "MIT",
+	"files": [
+		"dist/*.js",
+		"index.js"
+	],
+	"dependencies": {
+		"@linear/sdk": "^68.1.0",
+		"vscode-languageserver": "^9.0.1",
+		"vscode-languageserver-textdocument": "^1.0.12"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "^2.3.10",
+		"@types/node": "^23",
+		"typescript": "^5.9.3"
+	}
 }