@sebastienrousseau/crypto-lsp 0.0.7

package/LICENSE

@@ -0,0 +1,8 @@
+This project is dual-licensed under either of:
+
+  * Apache License, Version 2.0 — see LICENSE-APACHE
+  * MIT license — see LICENSE-MIT
+
+at your option.
+
+SPDX-License-Identifier: Apache-2.0 OR MIT

package/README.md

@@ -0,0 +1,102 @@
+<!-- SPDX-License-Identifier: Apache-2.0 OR MIT -->
+
+# `@sebastienrousseau/crypto-lsp`
+
+> Language Server Protocol (LSP) providing real-time cryptographic static analysis, quantum-vulnerability flagging, PEM/OpenPGP validation, and automated quick fixes for IDEs (VS Code, NeoVim, JetBrains, Emacs).
+
+[![Version](https://img.shields.io/npm/v/@sebastienrousseau/crypto-lsp.svg)](https://www.npmjs.com/package/@sebastienrousseau/crypto-lsp)
+[![License](https://img.shields.io/badge/license-MIT%20OR%20Apache--2.0-blue.svg)](https://opensource.org/licenses/MIT)
+
+---
+
+## Overview
+
+`@sebastienrousseau/crypto-lsp` brings institutional-grade cryptographic intelligence directly into developer IDEs via the Language Server Protocol (LSP 3.17). It actively monitors code buffers for broken primitives, inadequate key sizes, quantum vulnerabilities (Harvest-Now-Decrypt-Later risks), hardcoded secret material, and malformed PEM/OpenPGP blocks.
+
+## Key Capabilities
+
+- **Real-Time Static Cryptographic Linting**:
+  - `CRYPTO-001`: Detects broken hash functions (`MD5`, `SHA-1`, `MD4`, `RIPEMD160`).
+  - `CRYPTO-002`: Detects insecure symmetric ciphers and modes (`DES`, `3DES`, `RC4`, `ECB` mode).
+  - `CRYPTO-003`: Flags inadequate RSA key sizes (`< 2048` bits).
+  - `CRYPTO-004`: Quantum Vulnerability Flagging for classical public-key cryptography (`RSA`, `ECDSA`, `ECDH`, `Ed25519`) in long-term data security contexts.
+  - `CRYPTO-005`: Flags hardcoded secret/private keys in source files.
+  - `CRYPTO-006`: Validates PEM and OpenPGP armored block syntax.
+- **Intelligent QuickFix Actions**:
+  - Automated replacement of broken hashes (e.g. `MD5` -> `SHA-256`).
+  - Automated replacement of insecure cipher modes (e.g. `aes-128-ecb` -> `aes-256-gcm`).
+- **Interactive Hover Documentation**:
+  - Displays NIST FIPS 203/204/205 standards, quantum security levels, and regulatory compliance mapping (DORA, CRA, CNSA 2.0).
+- **Context-Aware Completion Provider**:
+  - Autocompletes modern symmetric, asymmetric, and post-quantum algorithms with recommended parameters.
+
+## Installation & CLI Usage
+
+```bash
+# Global installation
+pnpm add -g @sebastienrousseau/crypto-lsp
+
+# Run stdio LSP server
+crypto-lsp --stdio
+```
+
+## Editor Integration
+
+### VS Code
+
+Configure in your `.vscode/settings.json`:
+
+```json
+{
+  "crypto.lsp.serverPath": "crypto-lsp"
+}
+```
+
+### NeoVim (lspconfig)
+
+```lua
+vim.lsp.start({
+  name = 'crypto-lsp',
+  cmd = {'crypto-lsp', '--stdio'},
+  root_dir = vim.fs.dirname(vim.fs.find({'package.json', '.git'}, { upward = true })[1]),
+})
+```
+
+---
+
+## Development
+
+```bash
+pnpm --filter @sebastienrousseau/crypto-lsp run build
+pnpm --filter @sebastienrousseau/crypto-lsp run test
+pnpm --filter @sebastienrousseau/crypto-lsp run lint
+pnpm --filter @sebastienrousseau/crypto-lsp run format
+```
+
+All 18 packages in the Crypto Service workspace maintain a **100% coverage floor** across statements, branches, functions, and lines.
+
+---
+
+## Documentation
+
+- [Full Suite Documentation](https://docs.crypto-service.co/)
+- [API Reference (TypeDoc)](https://docs.crypto-service.co/packages/crypto-lsp/)
+- [Developer Guide](../../DEVELOPMENT.md)
+- [Security Policy](../../SECURITY.md)
+- [Architecture & Design](../../ARCHITECTURE.md)
+
+---
+
+## Stability guarantees
+
+Versions advance strictly one step at a time on the `0.0.x` line (`v0.0.1` → `v0.0.2` → `v0.0.3` ... → `v0.0.999` → `v0.1.0`). Work for every release iteration begins on a dedicated `feat/v<version>` branch.
+
+All 18 packages in the workspace move in lockstep. Public API signatures, cipher output formats, and serialization schemas are strictly versioned. Breaking changes to serialized formats or algorithm defaults are considered major breaking changes. Minimum toolchain upgrades (e.g. Node.js LTS floor) are governed by [POLICIES.md](../../docs/POLICIES.md).
+
+---
+
+## License
+
+Dual-licensed under [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0) or [MIT](https://opensource.org/licenses/MIT), at your option.
+
+Copyright (c) 2022-2026 Sebastien Rousseau and The Crypto Service Suite contributors.

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export declare function run(): void;
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AAKA,wBAAgB,GAAG,IAAI,IAAI,CAG1B"}

package/dist/cli.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const server_1 = require("./server");
+function run() {
+    const server = new server_1.CryptoLspServer();
+    server.listenStdio(process.stdin, process.stdout);
+}
+if (require.main === module) {
+    run();
+}
+//# sourceMappingURL=cli.js.map

package/dist/code-action.d.ts

@@ -0,0 +1,3 @@
+import { CodeAction, Diagnostic, Range } from "./types";
+export declare function getCodeActions(uri: string, text: string, range: Range, diagnostics: Diagnostic[]): CodeAction[];
+//# sourceMappingURL=code-action.d.ts.map

package/dist/code-action.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-action.d.ts","sourceRoot":"","sources":["../src/code-action.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAKxD,wBAAgB,cAAc,CAC5B,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,KAAK,EACZ,WAAW,EAAE,UAAU,EAAE,GACxB,UAAU,EAAE,CAyId"}

package/dist/code-action.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCodeActions = getCodeActions;
+function getCodeActions(uri, text, range, diagnostics) {
+    const actions = [];
+    const lines = text.split(/\r?\n/);
+    const targetLine = lines[range.start.line];
+    if (targetLine === undefined) {
+        return actions;
+    }
+    for (const diagnostic of diagnostics) {
+        if (diagnostic.range.start.line !== range.start.line) {
+            continue;
+        }
+        if (diagnostic.code === "CRYPTO-001") {
+            actions.push({
+                title: "Replace with secure SHA-256",
+                kind: "quickfix",
+                diagnostics: [diagnostic],
+                isPreferred: true,
+                edit: {
+                    changes: {
+                        [uri]: [
+                            {
+                                range: diagnostic.range,
+                                newText: "sha256",
+                            },
+                        ],
+                    },
+                },
+            });
+            actions.push({
+                title: "Replace with high-security SHA-512",
+                kind: "quickfix",
+                diagnostics: [diagnostic],
+                edit: {
+                    changes: {
+                        [uri]: [
+                            {
+                                range: diagnostic.range,
+                                newText: "sha512",
+                            },
+                        ],
+                    },
+                },
+            });
+        }
+        if (diagnostic.code === "CRYPTO-002") {
+            actions.push({
+                title: "Upgrade to authenticated AES-256-GCM",
+                kind: "quickfix",
+                diagnostics: [diagnostic],
+                isPreferred: true,
+                edit: {
+                    changes: {
+                        [uri]: [
+                            {
+                                range: diagnostic.range,
+                                newText: "aes-256-gcm",
+                            },
+                        ],
+                    },
+                },
+            });
+            actions.push({
+                title: "Upgrade to ChaCha20-Poly1305 (zero-latency AEAD)",
+                kind: "quickfix",
+                diagnostics: [diagnostic],
+                edit: {
+                    changes: {
+                        [uri]: [
+                            {
+                                range: diagnostic.range,
+                                newText: "chacha20-poly1305",
+                            },
+                        ],
+                    },
+                },
+            });
+        }
+        if (diagnostic.code === "CRYPTO-003") {
+            actions.push({
+                title: "Upgrade key length to 3072 bits (CNSA compliant)",
+                kind: "quickfix",
+                diagnostics: [diagnostic],
+                isPreferred: true,
+                edit: {
+                    changes: {
+                        [uri]: [
+                            {
+                                range: diagnostic.range,
+                                newText: "modulusLength: 3072",
+                            },
+                        ],
+                    },
+                },
+            });
+        }
+        if (diagnostic.code === "CRYPTO-004") {
+            actions.push({
+                title: "Migrate to Post-Quantum ML-KEM-768 (NIST FIPS 203)",
+                kind: "quickfix",
+                diagnostics: [diagnostic],
+                isPreferred: true,
+                edit: {
+                    changes: {
+                        [uri]: [
+                            {
+                                range: diagnostic.range,
+                                newText: "ml-kem-768",
+                            },
+                        ],
+                    },
+                },
+            });
+            actions.push({
+                title: "Migrate to Post-Quantum ML-DSA-65 (NIST FIPS 204)",
+                kind: "quickfix",
+                diagnostics: [diagnostic],
+                edit: {
+                    changes: {
+                        [uri]: [
+                            {
+                                range: diagnostic.range,
+                                newText: "ml-dsa-65",
+                            },
+                        ],
+                    },
+                },
+            });
+        }
+    }
+    return actions;
+}
+//# sourceMappingURL=code-action.js.map

package/dist/completion.d.ts

@@ -0,0 +1,3 @@
+import { CompletionItem } from "./types";
+export declare function getCompletions(): CompletionItem[];
+//# sourceMappingURL=completion.d.ts.map

package/dist/completion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"completion.d.ts","sourceRoot":"","sources":["../src/completion.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AA2FzC,wBAAgB,cAAc,IAAI,cAAc,EAAE,CAEjD"}

package/dist/completion.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCompletions = getCompletions;
+const COMPLETION_ITEMS = [
+    {
+        label: "ML-KEM-512",
+        kind: 12,
+        detail: "NIST FIPS 203 Category 1 Key Encapsulation",
+        documentation: "Post-quantum lattice KEM for 128-bit quantum security.",
+        insertText: "ml-kem-512",
+    },
+    {
+        label: "ML-KEM-768",
+        kind: 12,
+        detail: "NIST FIPS 203 Category 3 Key Encapsulation (Recommended)",
+        documentation: "Standard post-quantum lattice KEM for general security.",
+        insertText: "ml-kem-768",
+    },
+    {
+        label: "ML-KEM-1024",
+        kind: 12,
+        detail: "NIST FIPS 203 Category 5 Key Encapsulation (CNSA 2.0)",
+        documentation: "High-security post-quantum lattice KEM.",
+        insertText: "ml-kem-1024",
+    },
+    {
+        label: "ML-DSA-44",
+        kind: 12,
+        detail: "NIST FIPS 204 Category 2 Digital Signature",
+        documentation: "Lattice-based deterministic digital signature.",
+        insertText: "ml-dsa-44",
+    },
+    {
+        label: "ML-DSA-65",
+        kind: 12,
+        detail: "NIST FIPS 204 Category 3 Digital Signature (Recommended)",
+        documentation: "Standard lattice-based digital signature.",
+        insertText: "ml-dsa-65",
+    },
+    {
+        label: "ML-DSA-87",
+        kind: 12,
+        detail: "NIST FIPS 204 Category 5 Digital Signature (CNSA 2.0)",
+        documentation: "High-security lattice-based digital signature.",
+        insertText: "ml-dsa-87",
+    },
+    {
+        label: "aes-256-gcm",
+        kind: 12,
+        detail: "NIST SP 800-38D AEAD",
+        documentation: "256-bit AES in Galois/Counter Mode with 128-bit authentication tag.",
+        insertText: "aes-256-gcm",
+    },
+    {
+        label: "chacha20-poly1305",
+        kind: 12,
+        detail: "RFC 8439 AEAD",
+        documentation: "High-performance authenticated cipher immune to cache-timing attacks.",
+        insertText: "chacha20-poly1305",
+    },
+    {
+        label: "sha256",
+        kind: 12,
+        detail: "NIST FIPS 180-4 Secure Hash",
+        documentation: "256-bit cryptographic hash function.",
+        insertText: "sha256",
+    },
+    {
+        label: "sha384",
+        kind: 12,
+        detail: "NIST FIPS 180-4 Secure Hash (CNSA 2.0)",
+        documentation: "384-bit cryptographic hash function.",
+        insertText: "sha384",
+    },
+    {
+        label: "sha512",
+        kind: 12,
+        detail: "NIST FIPS 180-4 Secure Hash",
+        documentation: "512-bit cryptographic hash function.",
+        insertText: "sha512",
+    },
+];
+function getCompletions() {
+    return COMPLETION_ITEMS;
+}
+//# sourceMappingURL=completion.js.map

package/dist/diagnostics.d.ts

@@ -0,0 +1,3 @@
+import { Diagnostic } from "./types";
+export declare function analyzeDocument(_uri: string, text: string): Diagnostic[];
+//# sourceMappingURL=diagnostics.d.ts.map

package/dist/diagnostics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics.d.ts","sourceRoot":"","sources":["../src/diagnostics.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAS,MAAM,SAAS,CAAC;AAM5C,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,EAAE,CA0GxE"}

package/dist/diagnostics.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeDocument = analyzeDocument;
+const rules_1 = require("./rules");
+function analyzeDocument(_uri, text) {
+    const diagnostics = [];
+    const lines = text.split(/\r?\n/);
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+        const line = lines[lineIndex];
+        const brokenHashRegex = /["'](md5|sha1|sha-1|md4|ripemd160)["']/gi;
+        let match;
+        while ((match = brokenHashRegex.exec(line)) !== null) {
+            const startChar = match.index + 1;
+            const endChar = startChar + match[1].length;
+            const rule = rules_1.CRYPTO_RULES["CRYPTO-001"];
+            diagnostics.push({
+                range: createRange(lineIndex, startChar, lineIndex, endChar),
+                severity: rule.severity,
+                code: rule.id,
+                source: "crypto-lsp",
+                message: `${rule.description} ${rule.recommendation}`,
+            });
+        }
+        const insecureCipherRegex = /["'](aes-(?:128|192|256)-ecb|des|3des|des-ede3|rc4|blowfish)["']/gi;
+        while ((match = insecureCipherRegex.exec(line)) !== null) {
+            const startChar = match.index + 1;
+            const endChar = startChar + match[1].length;
+            const rule = rules_1.CRYPTO_RULES["CRYPTO-002"];
+            diagnostics.push({
+                range: createRange(lineIndex, startChar, lineIndex, endChar),
+                severity: rule.severity,
+                code: rule.id,
+                source: "crypto-lsp",
+                message: `${rule.description} ${rule.recommendation}`,
+            });
+        }
+        const weakRsaRegex = /(?:modulusLength|bits)\s*[:=]\s*(512|1024)\b/gi;
+        while ((match = weakRsaRegex.exec(line)) !== null) {
+            const startChar = match.index;
+            const endChar = match.index + match[0].length;
+            const rule = rules_1.CRYPTO_RULES["CRYPTO-003"];
+            diagnostics.push({
+                range: createRange(lineIndex, startChar, lineIndex, endChar),
+                severity: rule.severity,
+                code: rule.id,
+                source: "crypto-lsp",
+                message: `${rule.description} (${match[1]} bits detected). ${rule.recommendation}`,
+            });
+        }
+        const classicalPqRegex = /(?:algorithm\s*[:=]\s*|generateKeyPair(?:Sync)?\s*\(\s*)["'](rsa|ec|ecdsa|ecdh|ed25519)["']/gi;
+        while ((match = classicalPqRegex.exec(line)) !== null) {
+            const alg = match[1];
+            const startChar = line.indexOf(alg, match.index);
+            const endChar = startChar + alg.length;
+            const rule = rules_1.CRYPTO_RULES["CRYPTO-004"];
+            diagnostics.push({
+                range: createRange(lineIndex, startChar, lineIndex, endChar),
+                severity: rule.severity,
+                code: rule.id,
+                source: "crypto-lsp",
+                message: `${rule.description} (${alg.toUpperCase()} detected). ${rule.recommendation}`,
+            });
+        }
+        const hardcodedKeyRegex = /(?:secret_key|private_key|apiKey|cryptoKey)\s*[:=]\s*["']([0-9a-fA-F]{32,})["']/gi;
+        while ((match = hardcodedKeyRegex.exec(line)) !== null) {
+            const startChar = line.indexOf(match[1], match.index);
+            const endChar = startChar + match[1].length;
+            const rule = rules_1.CRYPTO_RULES["CRYPTO-005"];
+            diagnostics.push({
+                range: createRange(lineIndex, startChar, lineIndex, endChar),
+                severity: rule.severity,
+                code: rule.id,
+                source: "crypto-lsp",
+                message: `${rule.description} ${rule.recommendation}`,
+            });
+        }
+        if (line.includes("-----BEGIN") &&
+            !line.match(/-----BEGIN [A-Z0-9 ]+-----/)) {
+            const startChar = line.indexOf("-----BEGIN");
+            const endChar = line.length;
+            const rule = rules_1.CRYPTO_RULES["CRYPTO-006"];
+            diagnostics.push({
+                range: createRange(lineIndex, startChar, lineIndex, endChar),
+                severity: rule.severity,
+                code: rule.id,
+                source: "crypto-lsp",
+                message: `${rule.description} ${rule.recommendation}`,
+            });
+        }
+    }
+    return diagnostics;
+}
+function createRange(startLine, startChar, endLine, endChar) {
+    return {
+        start: { line: startLine, character: startChar },
+        end: { line: endLine, character: endChar },
+    };
+}
+//# sourceMappingURL=diagnostics.js.map

package/dist/hover.d.ts

@@ -0,0 +1,3 @@
+import { Hover, Position } from "./types";
+export declare function getHover(text: string, position: Position): Hover | null;
+//# sourceMappingURL=hover.d.ts.map

package/dist/hover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hover.d.ts","sourceRoot":"","sources":["../src/hover.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAmG1C,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,KAAK,GAAG,IAAI,CAsCvE"}

package/dist/hover.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHover = getHover;
+const KNOWLEDGE_BASE = {
+    "ml-kem": {
+        title: "ML-KEM (Module-Lattice-Based Key-Encapsulation Mechanism)",
+        category: "Post-Quantum Key Exchange",
+        securityLevel: "NIST Security Categories 1, 3, 5 (ML-KEM-512, 768, 1024)",
+        quantumSafe: true,
+        standard: "NIST FIPS 203 (Final August 2024)",
+        description: "Primary post-quantum key encapsulation mechanism standardized by NIST to replace classical Diffie-Hellman and RSA key transport against quantum decryption.",
+    },
+    "ml-dsa": {
+        title: "ML-DSA (Module-Lattice-Based Digital Signature Algorithm)",
+        category: "Post-Quantum Digital Signature",
+        securityLevel: "NIST Security Categories 2, 3, 5 (ML-DSA-44, 65, 87)",
+        quantumSafe: true,
+        standard: "NIST FIPS 204 (Final August 2024)",
+        description: "Primary post-quantum digital signature algorithm standardized by NIST based on the CRYSTALS-Dilithium lattice problem.",
+    },
+    "slh-dsa": {
+        title: "SLH-DSA (Stateless Hash-Based Digital Signature Algorithm)",
+        category: "Post-Quantum Digital Signature",
+        securityLevel: "NIST Security Categories 1, 3, 5 (SPHINCS+)",
+        quantumSafe: true,
+        standard: "NIST FIPS 205 (Final August 2024)",
+        description: "Stateless hash-based digital signature serving as a conservative mathematical fallback independent of structured lattice hardness assumptions.",
+    },
+    "aes-256-gcm": {
+        title: "AES-256-GCM (Galois/Counter Mode)",
+        category: "Authenticated Symmetric Cipher (AEAD)",
+        securityLevel: "256-bit key (128-bit quantum security via Grover's algorithm)",
+        quantumSafe: true,
+        standard: "NIST SP 800-38D / FIPS 197",
+        description: "Industry-standard authenticated encryption providing high-throughput confidentiality and data integrity with hardware acceleration.",
+    },
+    "chacha20-poly1305": {
+        title: "ChaCha20-Poly1305",
+        category: "Authenticated Symmetric Cipher (AEAD)",
+        securityLevel: "256-bit key",
+        quantumSafe: true,
+        standard: "RFC 8439 / IETF",
+        description: "High-speed stream cipher with Poly1305 authenticator, immune to cache-timing side-channel attacks on architectures without AES-NI instructions.",
+    },
+    ed25519: {
+        title: "Ed25519 (Edwards-curve Digital Signature Algorithm)",
+        category: "Classical Elliptic Curve Signature",
+        securityLevel: "128-bit classical security margin",
+        quantumSafe: false,
+        standard: "RFC 8032 / FIPS 186-5",
+        description: "Fast, deterministic signature scheme over Curve25519. Vulnerable to Shor's algorithm on a Cryptanalytically Relevant Quantum Computer (CRQC).",
+    },
+    rsa: {
+        title: "RSA (Rivest-Shamir-Adleman)",
+        category: "Classical Public-Key Cryptosystem",
+        securityLevel: "2048-bit: ~112-bit security | 3072-bit: ~128-bit security",
+        quantumSafe: false,
+        standard: "PKCS #1 / RFC 8017 / NIST SP 800-56B",
+        description: "Classical integer factorization-based cryptosystem. Fully vulnerable to polynomial-time recovery via Shor's algorithm on a CRQC.",
+    },
+    md5: {
+        title: "MD5 (Message Digest Algorithm 5)",
+        category: "Cryptographic Hash Function (DEPRECATED)",
+        securityLevel: "0-bit collision resistance (Cryptographically Broken)",
+        quantumSafe: false,
+        standard: "DEPRECATED (RFC 6151 / NIST SP 800-131A)",
+        description: "Severely vulnerable to practical collision attacks. Must never be used for security-sensitive operations or signatures.",
+    },
+    "sha-1": {
+        title: "SHA-1 (Secure Hash Algorithm 1)",
+        category: "Cryptographic Hash Function (DEPRECATED)",
+        securityLevel: "< 60-bit collision resistance (Demonstrated Collisions)",
+        quantumSafe: false,
+        standard: "DEPRECATED (NIST SP 800-131A / SHAttered)",
+        description: "Practical collisions generated since 2017. Disallowed for digital signatures and certificates across all modern compliance regimes.",
+    },
+};
+function getHover(text, position) {
+    const lines = text.split(/\r?\n/);
+    if (position.line < 0 || position.line >= lines.length) {
+        return null;
+    }
+    const line = lines[position.line];
+    const char = position.character;
+    for (const [key, doc] of Object.entries(KNOWLEDGE_BASE)) {
+        const regex = new RegExp(`\\b${key.replace(/-/g, "[ -]?")}\\b`, "gi");
+        let match;
+        while ((match = regex.exec(line)) !== null) {
+            const start = match.index;
+            const end = start + match[0].length;
+            if (char >= start && char <= end) {
+                const md = [
+                    `### ${doc.title}`,
+                    `**Category:** ${doc.category}`,
+                    `**Security:** ${doc.securityLevel}`,
+                    `**Quantum Resistant:** ${doc.quantumSafe ? "✅ Yes" : "❌ No (Vulnerable to Shor's Algorithm)"}`,
+                    `**Standard:** ${doc.standard}`,
+                    "",
+                    doc.description,
+                ].join("\n\n");
+                return {
+                    contents: { kind: "markdown", value: md },
+                    range: {
+                        start: { line: position.line, character: start },
+                        end: { line: position.line, character: end },
+                    },
+                };
+            }
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=hover.js.map

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./types";
+export * from "./rules";
+export * from "./diagnostics";
+export * from "./hover";
+export * from "./code-action";
+export * from "./completion";
+export * from "./server";
+export * from "./cli";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAC9B,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,OAAO,CAAC"}

package/dist/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./rules"), exports);
+__exportStar(require("./diagnostics"), exports);
+__exportStar(require("./hover"), exports);
+__exportStar(require("./code-action"), exports);
+__exportStar(require("./completion"), exports);
+__exportStar(require("./server"), exports);
+__exportStar(require("./cli"), exports);
+//# sourceMappingURL=index.js.map

package/dist/rules.d.ts

@@ -0,0 +1,10 @@
+import { DiagnosticSeverity } from "./types";
+export interface CryptoRule {
+    id: string;
+    name: string;
+    severity: DiagnosticSeverity;
+    description: string;
+    recommendation: string;
+}
+export declare const CRYPTO_RULES: Record<string, CryptoRule>;
+//# sourceMappingURL=rules.d.ts.map

package/dist/rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.d.ts","sourceRoot":"","sources":["../src/rules.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAE7C,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAqDnD,CAAC"}

package/dist/rules.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CRYPTO_RULES = void 0;
+const types_1 = require("./types");
+exports.CRYPTO_RULES = {
+    "CRYPTO-001": {
+        id: "CRYPTO-001",
+        name: "Broken Hash Function",
+        severity: types_1.DiagnosticSeverity.Error,
+        description: "Use of broken cryptographic hash function (MD5, SHA-1, MD4, RIPEMD160) vulnerable to collision attacks.",
+        recommendation: "Migrate to SHA-256, SHA-384, SHA-512, or SHA3-256.",
+    },
+    "CRYPTO-002": {
+        id: "CRYPTO-002",
+        name: "Insecure Symmetric Cipher or Mode",
+        severity: types_1.DiagnosticSeverity.Error,
+        description: "Use of deprecated cipher (DES, 3DES, RC4) or ECB mode which leaks plaintext patterns.",
+        recommendation: "Migrate to AES-256-GCM or ChaCha20-Poly1305 with unique 96-bit nonce.",
+    },
+    "CRYPTO-003": {
+        id: "CRYPTO-003",
+        name: "Inadequate Key Size",
+        severity: types_1.DiagnosticSeverity.Error,
+        description: "RSA key length below 2048 bits provides insufficient security margin.",
+        recommendation: "Use RSA with >= 2048 bits (3072+ recommended) or migrate to Ed25519 / ML-DSA.",
+    },
+    "CRYPTO-004": {
+        id: "CRYPTO-004",
+        name: "Quantum Vulnerable Public-Key Cryptography",
+        severity: types_1.DiagnosticSeverity.Warning,
+        description: "Classical public key algorithm is vulnerable to Shor's algorithm on a Cryptanalytically Relevant Quantum Computer (CRQC).",
+        recommendation: "Transition to NIST FIPS 203 (ML-KEM) for KEM and FIPS 204 (ML-DSA) for digital signatures.",
+    },
+    "CRYPTO-005": {
+        id: "CRYPTO-005",
+        name: "Hardcoded Secret Material",
+        severity: types_1.DiagnosticSeverity.Error,
+        description: "Hardcoded secret or private cryptographic key detected in source code.",
+        recommendation: "Store keys in environment variables, hardware security modules (HSM), or KMS.",
+    },
+    "CRYPTO-006": {
+        id: "CRYPTO-006",
+        name: "Malformed PEM Block",
+        severity: types_1.DiagnosticSeverity.Warning,
+        description: "Malformed or unterminated PEM header structure.",
+        recommendation: "Ensure valid RFC 7468 PEM encapsulation with matching BEGIN and END boundaries.",
+    },
+};
+//# sourceMappingURL=rules.js.map

package/dist/server.d.ts

@@ -0,0 +1,10 @@
+import { JSONRPCRequest, JSONRPCResponse } from "./types";
+export declare class CryptoLspServer {
+    private documents;
+    private initialized;
+    isInitialized(): boolean;
+    getDocument(uri: string): string | undefined;
+    handleRequest(request: JSONRPCRequest): Promise<JSONRPCResponse | null>;
+    listenStdio(input?: NodeJS.ReadableStream, output?: NodeJS.WritableStream): void;
+}
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAIA,OAAO,EAGL,cAAc,EACd,eAAe,EAIhB,MAAM,SAAS,CAAC;AAUjB,qBAAa,eAAe;IAC1B,OAAO,CAAC,SAAS,CAAkC;IACnD,OAAO,CAAC,WAAW,CAAS;IAErB,aAAa,IAAI,OAAO;IAIxB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAItC,aAAa,CACxB,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC;IAkJ3B,WAAW,CAChB,KAAK,GAAE,MAAM,CAAC,cAA8B,EAC5C,MAAM,GAAE,MAAM,CAAC,cAA+B,GAC7C,IAAI;CA4BR"}

package/dist/server.js

@@ -0,0 +1,184 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoLspServer = void 0;
+const node_readline_1 = __importDefault(require("node:readline"));
+const node_process_1 = __importDefault(require("node:process"));
+const diagnostics_1 = require("./diagnostics");
+const hover_1 = require("./hover");
+const code_action_1 = require("./code-action");
+const completion_1 = require("./completion");
+const version_1 = require("./version");
+class CryptoLspServer {
+    documents = new Map();
+    initialized = false;
+    isInitialized() {
+        return this.initialized;
+    }
+    getDocument(uri) {
+        return this.documents.get(uri);
+    }
+    async handleRequest(request) {
+        if (request.jsonrpc !== "2.0") {
+            return {
+                jsonrpc: "2.0",
+                id: request.id ?? null,
+                error: {
+                    code: -32600,
+                    message: "Invalid Request: jsonrpc must be '2.0'",
+                },
+            };
+        }
+        const id = request.id ?? null;
+        const params = request.params;
+        switch (request.method) {
+            case "initialize": {
+                this.initialized = true;
+                const result = {
+                    capabilities: {
+                        textDocumentSync: 1,
+                        hoverProvider: true,
+                        codeActionProvider: true,
+                        completionProvider: {
+                            resolveProvider: false,
+                            triggerCharacters: ['"', "'", "-"],
+                        },
+                    },
+                    serverInfo: {
+                        name: "crypto-lsp",
+                        version: version_1.VERSION,
+                    },
+                };
+                return { jsonrpc: "2.0", id, result };
+            }
+            case "initialized": {
+                return null;
+            }
+            case "textDocument/didOpen": {
+                const td = params
+                    ? params.textDocument
+                    : null;
+                if (td) {
+                    this.documents.set(td.uri, td.text);
+                    const diagnostics = (0, diagnostics_1.analyzeDocument)(td.uri, td.text);
+                    const publishParams = {
+                        uri: td.uri,
+                        diagnostics,
+                    };
+                    return {
+                        jsonrpc: "2.0",
+                        id: null,
+                        result: publishParams,
+                    };
+                }
+                return null;
+            }
+            case "textDocument/didChange": {
+                const td = params ? params.textDocument : null;
+                const changes = params
+                    ? params.contentChanges
+                    : null;
+                if (td && changes && changes.length > 0) {
+                    const newText = changes[0].text;
+                    this.documents.set(td.uri, newText);
+                    const diagnostics = (0, diagnostics_1.analyzeDocument)(td.uri, newText);
+                    const publishParams = {
+                        uri: td.uri,
+                        diagnostics,
+                    };
+                    return {
+                        jsonrpc: "2.0",
+                        id: null,
+                        result: publishParams,
+                    };
+                }
+                return null;
+            }
+            case "textDocument/didClose": {
+                const td = params ? params.textDocument : null;
+                if (td) {
+                    this.documents.delete(td.uri);
+                }
+                return null;
+            }
+            case "textDocument/hover": {
+                const td = params ? params.textDocument : null;
+                const pos = params ? params.position : null;
+                if (td && pos) {
+                    const text = this.documents.get(td.uri) || "";
+                    const hover = (0, hover_1.getHover)(text, pos);
+                    return { jsonrpc: "2.0", id, result: hover };
+                }
+                return { jsonrpc: "2.0", id, result: null };
+            }
+            case "textDocument/codeAction": {
+                const td = params ? params.textDocument : null;
+                const range = params ? params.range : null;
+                const context = params
+                    ? params.context
+                    : null;
+                if (td && range) {
+                    const text = this.documents.get(td.uri) || "";
+                    const diags = context
+                        ? context.diagnostics
+                        : (0, diagnostics_1.analyzeDocument)(td.uri, text);
+                    const actions = (0, code_action_1.getCodeActions)(td.uri, text, range, diags);
+                    return { jsonrpc: "2.0", id, result: actions };
+                }
+                return { jsonrpc: "2.0", id, result: [] };
+            }
+            case "textDocument/completion": {
+                const items = (0, completion_1.getCompletions)();
+                return { jsonrpc: "2.0", id, result: items };
+            }
+            case "shutdown": {
+                return { jsonrpc: "2.0", id, result: null };
+            }
+            case "exit": {
+                return null;
+            }
+            default:
+                return {
+                    jsonrpc: "2.0",
+                    id,
+                    error: {
+                        code: -32601,
+                        message: `Method not found: ${request.method}`,
+                    },
+                };
+        }
+    }
+    listenStdio(input = node_process_1.default.stdin, output = node_process_1.default.stdout) {
+        const rl = node_readline_1.default.createInterface({
+            input,
+            output: undefined,
+            terminal: false,
+        });
+        rl.on("line", async (line) => {
+            const trimmed = line.trim();
+            if (!trimmed)
+                return;
+            if (trimmed.startsWith("Content-Length:"))
+                return;
+            try {
+                const req = JSON.parse(trimmed);
+                const res = await this.handleRequest(req);
+                if (res !== null) {
+                    output.write(JSON.stringify(res) + "\n");
+                }
+            }
+            catch {
+                const parseError = {
+                    jsonrpc: "2.0",
+                    id: null,
+                    error: { code: -32700, message: "Parse error: invalid JSON" },
+                };
+                output.write(JSON.stringify(parseError) + "\n");
+            }
+        });
+    }
+}
+exports.CryptoLspServer = CryptoLspServer;
+//# sourceMappingURL=server.js.map

package/dist/types.d.ts

@@ -0,0 +1,111 @@
+export interface Position {
+    line: number;
+    character: number;
+}
+export interface Range {
+    start: Position;
+    end: Position;
+}
+export declare enum DiagnosticSeverity {
+    Error = 1,
+    Warning = 2,
+    Information = 3,
+    Hint = 4
+}
+export interface Diagnostic {
+    range: Range;
+    severity: DiagnosticSeverity;
+    code: string;
+    source: string;
+    message: string;
+}
+export interface TextDocumentItem {
+    uri: string;
+    languageId: string;
+    version: number;
+    text: string;
+}
+export interface TextDocumentContentChangeEvent {
+    text: string;
+}
+export interface DidOpenTextDocumentParams {
+    textDocument: TextDocumentItem;
+}
+export interface DidChangeTextDocumentParams {
+    textDocument: {
+        uri: string;
+        version: number;
+    };
+    contentChanges: TextDocumentContentChangeEvent[];
+}
+export interface DidCloseTextDocumentParams {
+    textDocument: {
+        uri: string;
+    };
+}
+export interface PublishDiagnosticsParams {
+    uri: string;
+    diagnostics: Diagnostic[];
+}
+export interface MarkupContent {
+    kind: "markdown" | "plaintext";
+    value: string;
+}
+export interface Hover {
+    contents: MarkupContent;
+    range?: Range;
+}
+export interface TextEdit {
+    range: Range;
+    newText: string;
+}
+export interface WorkspaceEdit {
+    changes?: Record<string, TextEdit[]>;
+}
+export interface CodeAction {
+    title: string;
+    kind?: string;
+    diagnostics?: Diagnostic[];
+    isPreferred?: boolean;
+    edit?: WorkspaceEdit;
+}
+export interface CompletionItem {
+    label: string;
+    kind: number;
+    detail?: string;
+    documentation?: string;
+    insertText?: string;
+}
+export interface ServerCapabilities {
+    textDocumentSync: number;
+    hoverProvider: boolean;
+    codeActionProvider: boolean;
+    completionProvider: {
+        resolveProvider: boolean;
+        triggerCharacters: string[];
+    };
+}
+export interface InitializeResult {
+    capabilities: ServerCapabilities;
+    serverInfo: {
+        name: string;
+        version: string;
+    };
+}
+export interface JSONRPCRequest {
+    jsonrpc: "2.0";
+    id?: number | string | null;
+    method: string;
+    params?: Record<string, unknown>;
+}
+export interface JSONRPCResponse {
+    jsonrpc: "2.0";
+    id: number | string | null;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiagnosticSeverity = void 0;
+var DiagnosticSeverity;
+(function (DiagnosticSeverity) {
+    DiagnosticSeverity[DiagnosticSeverity["Error"] = 1] = "Error";
+    DiagnosticSeverity[DiagnosticSeverity["Warning"] = 2] = "Warning";
+    DiagnosticSeverity[DiagnosticSeverity["Information"] = 3] = "Information";
+    DiagnosticSeverity[DiagnosticSeverity["Hint"] = 4] = "Hint";
+})(DiagnosticSeverity || (exports.DiagnosticSeverity = DiagnosticSeverity = {}));
+//# sourceMappingURL=types.js.map

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+export declare const VERSION: string;
+//# sourceMappingURL=version.d.ts.map

package/dist/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,OAAO,EAAE,MAIb,CAAC"}

package/dist/version.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+exports.VERSION = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(__dirname, "..", "package.json"), "utf8")).version;
+//# sourceMappingURL=version.js.map

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@sebastienrousseau/crypto-lsp",
+  "version": "0.0.7",
+  "description": "Language Server Protocol (LSP) providing real-time cryptographic static analysis, quantum-vulnerability flagging, PEM/OpenPGP validation, and automated quick fixes for IDEs.",
+  "author": "Sebastien Rousseau <sebastienrousseau@users.noreply.github.com>",
+  "license": "MIT OR Apache-2.0",
+  "homepage": "https://crypto-service.co",
+  "repository": {
+    "directory": "packages/crypto-lsp",
+    "type": "git",
+    "url": "git@github.com:sebastienrousseau/crypto-service.git"
+  },
+  "bugs": {
+    "url": "https://github.com/sebastienrousseau/crypto-service/issues"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "bin": {
+    "crypto-lsp": "./dist/cli.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "dist/**/*.d.ts.map"
+  ],
+  "dependencies": {
+    "@sebastienrousseau/crypto-lib": "0.0.7"
+  },
+  "devDependencies": {
+    "@types/chai": "^4.3.7",
+    "@types/chai-as-promised": "^8.0.2",
+    "@types/mocha": "^10.0.2",
+    "@types/node": "^26.4.1",
+    "c8": "^12.0.0",
+    "chai": "^4.5.0",
+    "chai-as-promised": "^7.1.2",
+    "mocha": "^10.8.2",
+    "rimraf": "^6.1.3",
+    "ts-node": "^10.9.2",
+    "typedoc": "^0.28.20",
+    "typescript": "~5.9.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc --build tsconfig.json",
+    "clean": "rimraf ./coverage ./dist ./docs",
+    "lint": "eslint --ext .ts src __tests__",
+    "lint:fix": "eslint --cache --fix --ext .ts src __tests__",
+    "format": "prettier --write src/**/*.ts",
+    "format:check": "prettier --check \"src/**/*.ts\"",
+    "test": "c8 --check-coverage --lines 100 --branches 100 --functions 100 --reporter=lcov --reporter=text mocha --config=.mocharc.cjs",
+    "docs": "typedoc"
+  }
+}