linear-ls 1.2.0 → 1.3.0

package/dist/server.js

@@ -9,6 +9,41 @@ const teams = new Map();
 const issues = new Map();
 const positions = new Map();
 let client;
+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) {
@@ -26,7 +61,7 @@ conn.onInitialize(async () => {
             textDocumentSync: node_1.TextDocumentSyncKind.Incremental,
             codeActionProvider: {},
             executeCommandProvider: {
-                commands: ["linear-ls.createTicket"],
+                commands: ["linear-ls.createIssue", "linear-ls.openIssue"],
             },
             hoverProvider: {},
             completionProvider: { resolveProvider: true },
@@ -40,29 +75,59 @@ conn.onInitialize(async () => {
         },
     };
 });
-conn.onCodeAction((params) => {
+conn.onCodeAction(async (params) => {
+    const actions = [];
     if (params.context.triggerKind === node_1.CodeActionTriggerKind.Invoked) {
-        const textDocument = docs.get(params.textDocument.uri);
-        if (!textDocument) {
-            return;
+        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 text = textDocument.getText(params.range);
-        if (!text) {
-            return;
+    }
+    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],
+                        },
+                    });
+                }
+            }
         }
-        const action = {
-            title: "Create Ticket from Selection",
-            kind: node_1.CodeActionKind.RefactorRewrite,
-            command: {
-                command: "linear-ls.createTicket",
-                title: "Create Ticket",
-                arguments: [params.textDocument.uri, params.range, text.trim()],
-            },
-        };
-        return [action];
     }
+    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) {
@@ -117,7 +182,7 @@ conn.onExecuteCommand(async (params) => {
 let documentChangeTimeout;
 docs.onDidChangeContent((change) => {
     clearTimeout(documentChangeTimeout);
-    documentChangeTimeout = setTimeout(() => {
+    documentChangeTimeout = setTimeout(async () => {
         const text = change.document.getText();
         const documentPositions = [];
         const teamKeys = Array.from(teams.keys());
@@ -144,33 +209,32 @@ docs.onDidChangeContent((change) => {
             });
         });
         positions.set(change.document.uri, documentPositions);
-    }, 200);
+        await diagnostics(change.document);
+    }, 1000);
 });
 conn.onHover(async (params) => {
-    const documentPositions = positions.get(params.textDocument.uri);
-    if (!documentPositions) {
+    const docPositions = positions.get(params.textDocument.uri);
+    if (!docPositions) {
         return;
     }
-    const textDocument = docs.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",
     };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "linear-ls",
-	"version": "1.2.0",
+	"version": "1.3.0",
 	"description": "Linear Language Server",
 	"bin": "index.js",
 	"main": "index.js",