@akira-tl/forgerelay 0.3.7 → 0.4.1

package/dist/lsp/language-server-config.js

@@ -0,0 +1,313 @@
+import { access, readFile, realpath } from "node:fs/promises";
+import { constants } from "node:fs";
+import { createHash } from "node:crypto";
+import { delimiter, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { z } from "zod";
+export class LanguageServerConfigurationError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "LanguageServerConfigurationError";
+    }
+}
+const definitionSchema = z.object({
+    enabled: z.boolean().optional(),
+    command: z.string().min(1).optional(),
+    args: z.array(z.string()).optional(),
+    env: z.record(z.string(), z.string()).optional(),
+    languages: z.array(z.string().min(1)).min(1).optional(),
+    extensions: z.array(z.string().regex(/^\./)).min(1).optional(),
+    languageIdByExtension: z.record(z.string().regex(/^\./), z.string().min(1)).optional(),
+    projectMarkers: z.array(z.string().min(1)).optional(),
+}).strict();
+const configSchema = z.record(z.string().min(1), definitionSchema);
+const BUILTIN_DEFINITIONS = {
+    typescript: {
+        executableCandidates: ["typescript-language-server"],
+        args: ["--stdio"],
+        languages: ["typescript", "typescriptreact", "javascript", "javascriptreact"],
+        extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"],
+        languageIdByExtension: {
+            ".ts": "typescript",
+            ".tsx": "typescriptreact",
+            ".js": "javascript",
+            ".jsx": "javascriptreact",
+            ".mjs": "javascript",
+            ".cjs": "javascript",
+        },
+        projectMarkers: ["tsconfig.json", "jsconfig.json", "package.json"],
+    },
+    pyright: {
+        executableCandidates: ["pyright-langserver"],
+        args: ["--stdio"],
+        languages: ["python"],
+        extensions: [".py", ".pyi"],
+        languageIdByExtension: { ".py": "python", ".pyi": "python" },
+        projectMarkers: ["pyrightconfig.json", "pyproject.toml", "setup.cfg", "setup.py"],
+    },
+    "rust-analyzer": {
+        executableCandidates: ["rust-analyzer"],
+        languages: ["rust"],
+        extensions: [".rs"],
+        languageIdByExtension: { ".rs": "rust" },
+        projectMarkers: ["Cargo.toml"],
+    },
+    gopls: {
+        executableCandidates: ["gopls"],
+        languages: ["go"],
+        extensions: [".go"],
+        languageIdByExtension: { ".go": "go" },
+        projectMarkers: ["go.work", "go.mod"],
+    },
+    clangd: {
+        executableCandidates: ["clangd"],
+        languages: ["c", "cpp", "objective-c", "objective-cpp"],
+        extensions: [".c", ".cc", ".cpp", ".cxx", ".h", ".hh", ".hpp", ".hxx", ".m", ".mm"],
+        languageIdByExtension: {
+            ".c": "c",
+            ".cc": "cpp",
+            ".cpp": "cpp",
+            ".cxx": "cpp",
+            ".h": "cpp",
+            ".hh": "cpp",
+            ".hpp": "cpp",
+            ".hxx": "cpp",
+            ".m": "objective-c",
+            ".mm": "objective-cpp",
+        },
+        projectMarkers: ["compile_commands.json", "compile_flags.txt", ".clangd"],
+    },
+};
+export async function resolveLanguageProject(input) {
+    const workspaceRoot = await canonicalWorkspaceRoot(input.workspaceRoot);
+    const sourcePath = await resolveWorkspaceSourcePath(workspaceRoot, input.sourcePath);
+    const projectConfig = await loadProjectLanguageServerConfig(workspaceRoot);
+    const globalConfig = parseLanguageServerConfig(input.globalConfig ?? {}, "global ForgeRelay config");
+    const definitions = await effectiveDefinitions(globalConfig, projectConfig, input.env ?? process.env);
+    const extension = extname(sourcePath).toLowerCase();
+    const candidates = [];
+    for (const definition of definitions) {
+        if (!definition.extensions.includes(extension))
+            continue;
+        const projectRoot = await findLanguageProjectRoot(workspaceRoot, dirname(sourcePath), definition.projectMarkers);
+        if (!projectRoot)
+            continue;
+        candidates.push({ definition, projectRoot });
+    }
+    if (candidates.length === 0) {
+        throw new LanguageServerConfigurationError("code.language_service_unavailable", `No available Language-server definition matches ${relative(workspaceRoot, sourcePath) || "."}.`);
+    }
+    const sourceRank = { builtin: 0, global: 1, project: 2 };
+    const highestRank = Math.max(...candidates.map((candidate) => sourceRank[candidate.definition.source]));
+    const highest = candidates.filter((candidate) => sourceRank[candidate.definition.source] === highestRank);
+    const deepestLength = Math.max(...highest.map((candidate) => candidate.projectRoot.length));
+    const nearest = highest.filter((candidate) => candidate.projectRoot.length === deepestLength);
+    if (nearest.length !== 1) {
+        throw new LanguageServerConfigurationError("code.configuration_ambiguous", `Multiple Language-server definitions match ${relative(workspaceRoot, sourcePath)} at the same priority: ${nearest.map((candidate) => candidate.definition.id).join(", ")}.`);
+    }
+    return nearest[0];
+}
+export async function loadProjectLanguageServerConfig(workspaceRoot) {
+    const path = join(workspaceRoot, ".forgerelay", "language-servers.json");
+    try {
+        return parseLanguageServerConfig(JSON.parse(await readFile(path, "utf8")), path);
+    }
+    catch (error) {
+        if (isMissingFile(error))
+            return {};
+        if (error instanceof LanguageServerConfigurationError)
+            throw error;
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new LanguageServerConfigurationError("code.configuration_invalid", `Unable to load Language-server configuration at ${path}: ${reason}`);
+    }
+}
+export function parseLanguageServerConfig(value, label) {
+    const parsed = configSchema.safeParse(value ?? {});
+    if (!parsed.success) {
+        const details = parsed.error.issues
+            .map((issue) => `${issue.path.join(".") || "config"}: ${issue.message}`)
+            .join("; ");
+        throw new LanguageServerConfigurationError("code.configuration_invalid", `Invalid Language-server configuration in ${label}: ${details}`);
+    }
+    return parsed.data;
+}
+async function effectiveDefinitions(globalConfig, projectConfig, env) {
+    const ids = new Set([
+        ...Object.keys(BUILTIN_DEFINITIONS),
+        ...Object.keys(globalConfig),
+        ...Object.keys(projectConfig),
+    ]);
+    const definitions = [];
+    for (const id of ids) {
+        const builtin = BUILTIN_DEFINITIONS[id];
+        const global = globalConfig[id];
+        const project = projectConfig[id];
+        const source = project
+            ? "project"
+            : global
+                ? "global"
+                : "builtin";
+        const merged = {
+            id,
+            source,
+            ...(builtin ?? {}),
+            ...(global ?? {}),
+            ...(project ?? {}),
+            env: {
+                ...(builtin?.env ?? {}),
+                ...(global?.env ?? {}),
+                ...(project?.env ?? {}),
+            },
+            languageIdByExtension: {
+                ...(builtin?.languageIdByExtension ?? {}),
+                ...(global?.languageIdByExtension ?? {}),
+                ...(project?.languageIdByExtension ?? {}),
+            },
+        };
+        if (merged.enabled === false)
+            continue;
+        const languages = merged.languages ?? [];
+        const extensions = merged.extensions?.map((entry) => entry.toLowerCase()) ?? [];
+        if (languages.length === 0 || extensions.length === 0)
+            continue;
+        const languageIdByExtension = normalizeLanguageIds(id, merged, languages, extensions);
+        let command = merged.command;
+        if (!command && builtin?.executableCandidates) {
+            command = await findExecutable(builtin.executableCandidates, env);
+            if (!command)
+                continue;
+        }
+        if (!command) {
+            throw new LanguageServerConfigurationError("code.configuration_invalid", `Language-server definition ${id} requires a command.`);
+        }
+        const normalized = {
+            id,
+            command,
+            args: merged.args ?? [],
+            env: merged.env ?? {},
+            languages,
+            extensions,
+            languageIdByExtension,
+            projectMarkers: merged.projectMarkers ?? [],
+            source,
+        };
+        definitions.push({
+            ...normalized,
+            fingerprint: createHash("sha256").update(JSON.stringify(normalized)).digest("hex"),
+        });
+    }
+    return definitions;
+}
+function normalizeLanguageIds(id, definition, languages, extensions) {
+    const mapping = Object.fromEntries(Object.entries(definition.languageIdByExtension ?? {})
+        .map(([extension, languageId]) => [extension.toLowerCase(), languageId]));
+    for (let index = 0; index < extensions.length; index += 1) {
+        const extension = extensions[index];
+        if (mapping[extension])
+            continue;
+        if (languages.length === 1) {
+            mapping[extension] = languages[0];
+            continue;
+        }
+        if (languages.length === extensions.length) {
+            mapping[extension] = languages[index];
+            continue;
+        }
+        throw new LanguageServerConfigurationError("code.configuration_invalid", `Language-server definition ${id} must map extension ${extension} to a languageId when multiple language IDs do not align one-to-one with extensions.`);
+    }
+    for (const [extension, languageId] of Object.entries(mapping)) {
+        if (!extensions.includes(extension))
+            continue;
+        if (!languages.includes(languageId)) {
+            throw new LanguageServerConfigurationError("code.configuration_invalid", `Language-server definition ${id} maps ${extension} to unknown languageId ${languageId}.`);
+        }
+    }
+    return mapping;
+}
+async function findLanguageProjectRoot(workspaceRoot, startDirectory, markers) {
+    if (markers.length === 0)
+        return workspaceRoot;
+    let current = startDirectory;
+    while (isWithin(workspaceRoot, current)) {
+        for (const marker of markers) {
+            try {
+                await access(join(current, marker));
+                return current;
+            }
+            catch {
+                // Try the next marker or parent directory.
+            }
+        }
+        if (current === workspaceRoot)
+            break;
+        current = dirname(current);
+    }
+    return undefined;
+}
+async function canonicalWorkspaceRoot(inputPath) {
+    try {
+        return await realpath(resolve(inputPath));
+    }
+    catch {
+        throw new LanguageServerConfigurationError("code.language_service_unavailable", `Code-intelligence Workspace root does not exist: ${inputPath}`);
+    }
+}
+async function resolveWorkspaceSourcePath(workspaceRoot, inputPath) {
+    const candidate = resolve(workspaceRoot, inputPath);
+    if (!isWithin(workspaceRoot, candidate)) {
+        throw new LanguageServerConfigurationError("code.language_service_unavailable", `Code-intelligence source path must remain inside the Workspace: ${inputPath}`);
+    }
+    try {
+        const [canonicalRoot, canonicalCandidate] = await Promise.all([
+            realpath(workspaceRoot),
+            realpath(candidate),
+        ]);
+        if (!isWithin(canonicalRoot, canonicalCandidate)) {
+            throw new LanguageServerConfigurationError("code.language_service_unavailable", `Code-intelligence source path resolves outside the Workspace: ${inputPath}`);
+        }
+        return canonicalCandidate;
+    }
+    catch (error) {
+        if (error instanceof LanguageServerConfigurationError)
+            throw error;
+        throw new LanguageServerConfigurationError("code.language_service_unavailable", `Code-intelligence source path does not exist: ${inputPath}`);
+    }
+}
+async function findExecutable(candidates, env) {
+    for (const candidate of candidates) {
+        if (isAbsolute(candidate)) {
+            if (await executable(candidate))
+                return candidate;
+            continue;
+        }
+        const pathEntries = (env.PATH ?? "").split(delimiter).filter(Boolean);
+        const extensions = process.platform === "win32"
+            ? (env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";")
+            : [""];
+        for (const directory of pathEntries) {
+            for (const extension of extensions) {
+                const path = join(directory, process.platform === "win32" ? `${candidate}${extension}` : candidate);
+                if (await executable(path))
+                    return path;
+            }
+        }
+    }
+    return undefined;
+}
+async function executable(path) {
+    try {
+        await access(path, process.platform === "win32" ? constants.F_OK : constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isWithin(root, candidate) {
+    const rel = relative(root, candidate);
+    return rel === "" || (!rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel));
+}
+function isMissingFile(error) {
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
+}

package/dist/lsp/normalization/hover.js

@@ -0,0 +1,29 @@
+export function normalizeHoverContents(contents) {
+    if (Array.isArray(contents)) {
+        if (contents.length === 1)
+            return normalizeMarkedString(contents[0]);
+        return {
+            contents: contents.map(renderMarkedString).join("\n\n"),
+        };
+    }
+    if (isMarkupContent(contents)) {
+        return { contents: contents.value };
+    }
+    return normalizeMarkedString(contents);
+}
+function isMarkupContent(value) {
+    return typeof value === "object" && value !== null && "kind" in value;
+}
+function normalizeMarkedString(value) {
+    if (typeof value === "string")
+        return { contents: value };
+    return {
+        contents: value.value,
+        language: value.language,
+    };
+}
+function renderMarkedString(value) {
+    if (typeof value === "string")
+        return value;
+    return `\`\`\`${value.language}\n${value.value}\n\`\`\``;
+}

package/dist/lsp/position-encoding.js

@@ -0,0 +1,88 @@
+import { PositionEncodingKind } from "vscode-languageserver-protocol";
+import { CodeIntelligenceError } from "./code-intelligence-error.js";
+export function lspPositionFromUser(text, line, column, encoding) {
+    if (!Number.isInteger(line) || line < 1 || !Number.isInteger(column) || column < 1) {
+        throw new CodeIntelligenceError("code.invalid_position", `Code-intelligence positions are 1-based positive integers; received line=${line}, column=${column}.`);
+    }
+    const lines = text.split(/\r?\n/);
+    const sourceLine = lines[line - 1];
+    if (sourceLine === undefined) {
+        throw new CodeIntelligenceError("code.invalid_position", `Line ${line} is outside the document (${lines.length} lines).`);
+    }
+    const codePoints = Array.from(sourceLine);
+    const codePointIndex = column - 1;
+    if (codePointIndex > codePoints.length) {
+        throw new CodeIntelligenceError("code.invalid_position", `Column ${column} is outside line ${line} (${codePoints.length + 1} valid insertion positions).`);
+    }
+    const prefix = codePoints.slice(0, codePointIndex).join("");
+    return {
+        line: line - 1,
+        character: encodedLength(prefix, encoding),
+    };
+}
+export function wholeDocumentRange(text, encoding) {
+    const lines = text.split(/\r?\n/);
+    const lastLine = Math.max(0, lines.length - 1);
+    return {
+        start: { line: 0, character: 0 },
+        end: {
+            line: lastLine,
+            character: encodedLength(lines[lastLine] ?? "", encoding),
+        },
+    };
+}
+export function rangeFromLsp(text, range, encoding) {
+    return {
+        start: positionFromLsp(text, range.start, encoding),
+        end: positionFromLsp(text, range.end, encoding),
+    };
+}
+function positionFromLsp(text, position, encoding) {
+    const lines = text.split(/\r?\n/);
+    const sourceLine = lines[position.line];
+    if (sourceLine === undefined) {
+        throw new CodeIntelligenceError("code.invalid_position", `Language server returned line ${position.line} outside a ${lines.length}-line document.`);
+    }
+    return {
+        line: position.line + 1,
+        column: decodedCodePointOffset(sourceLine, position.character, encoding) + 1,
+    };
+}
+function encodedLength(text, encoding) {
+    if (encoding === PositionEncodingKind.UTF8)
+        return Buffer.byteLength(text, "utf8");
+    if (encoding === PositionEncodingKind.UTF32)
+        return Array.from(text).length;
+    return text.length;
+}
+function decodedCodePointOffset(text, encodedOffset, encoding) {
+    if (!Number.isInteger(encodedOffset) || encodedOffset < 0) {
+        throw new CodeIntelligenceError("code.invalid_position", `Language server returned invalid character offset ${encodedOffset}.`);
+    }
+    if (encoding === PositionEncodingKind.UTF32) {
+        if (encodedOffset > Array.from(text).length) {
+            throw new CodeIntelligenceError("code.invalid_position", `Language server returned character offset ${encodedOffset} outside its line.`);
+        }
+        return encodedOffset;
+    }
+    if (encoding === PositionEncodingKind.UTF16) {
+        if (encodedOffset > text.length) {
+            throw new CodeIntelligenceError("code.invalid_position", `Language server returned character offset ${encodedOffset} outside its line.`);
+        }
+        return Array.from(text.slice(0, encodedOffset)).length;
+    }
+    let bytes = 0;
+    let codePoints = 0;
+    for (const character of text) {
+        if (bytes === encodedOffset)
+            return codePoints;
+        bytes += Buffer.byteLength(character, "utf8");
+        codePoints += 1;
+        if (bytes > encodedOffset) {
+            throw new CodeIntelligenceError("code.invalid_position", `Language server returned UTF-8 offset ${encodedOffset} inside a code point.`);
+        }
+    }
+    if (bytes === encodedOffset)
+        return codePoints;
+    throw new CodeIntelligenceError("code.invalid_position", `Language server returned character offset ${encodedOffset} outside its line.`);
+}

package/dist/server.js

@@ -21,6 +21,7 @@ import { deletePath, renamePath } from "./file-mutations.js";
 import { downloadIncomingArtifact, isArtifactDownloadSupportedPlatform, } from "./artifact-tools.js";
 import { ArtifactError } from "./artifact-error.js";
 import { loadConfig } from "./config.js";
+import { CodeIntelligenceError, CodeIntelligenceManager } from "./lsp/code-intelligence.js";
 import { attachHookReports, HookRunner, runToolWithHooks } from "./hooks.js";
 import { checkHookConfiguration } from "./hook-cli.js";
 import { buildServerInstructions, buildShellMutationPolicy, buildToolDescriptions, toolNames, } from "./mcp/server-instructions.js";
@@ -743,7 +744,7 @@ function registerProcessTools(server, config, workspaces, processSessions, hooks
         });
     });
 }
-export function createMcpServer(config, workspaces, reviewCheckpoints, processSessions, localAgentProviders, incomingArtifactAdapters) {
+export function createMcpServer(config, workspaces, reviewCheckpoints, processSessions, localAgentProviders, incomingArtifactAdapters, codeIntelligence) {
     const toolDescriptions = buildToolDescriptions(config);
     const hooks = new HookRunner(config.hooks, config.logging, process.env, (workspaceId, result) => attachCompletedProcessNotices(processSessions, workspaceId, result));
     const incomingArtifactRegistry = new IncomingArtifactAdapterRegistry(incomingArtifactAdapters);
@@ -751,6 +752,22 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
     const reviewChangesAvailable = config.widgets === "changes";
     const capabilityRegistry = createCapabilityRegistry({
         inspectHooks: (workspaceRoot) => checkHookConfiguration(workspaceRoot, config.hooks),
+        codeIntelligence: {
+            available: true,
+            run: async (input, context) => {
+                try {
+                    return {
+                        value: await codeIntelligence.run(context.workspaceRoot, input),
+                    };
+                }
+                catch (error) {
+                    if (error instanceof CodeIntelligenceError) {
+                        throw new CapabilityError(error.code, error.message);
+                    }
+                    throw error;
+                }
+            },
+        },
         reviewChanges: {
             available: reviewChangesAvailable,
             unavailableReason: reviewChangesAvailable
@@ -2108,6 +2125,7 @@ export function createServer(config = loadConfig(), options = {}) {
     const workspaces = new WorkspaceRegistry(config, workspaceStore);
     const reviewCheckpoints = createReviewCheckpointManager();
     const processSessions = new ProcessManager();
+    const codeIntelligence = new CodeIntelligenceManager(config);
     const localAgentProviders = config.subagents
         ? getLocalAgentProviderAvailabilitySnapshot()
         : [];
@@ -2154,6 +2172,7 @@ export function createServer(config = loadConfig(), options = {}) {
             processesCompleted: processStats.completed,
             cachedWorkspaces: workspaces.cachedWorkspaceCount,
             reviewStates: reviewCheckpoints.stateCount,
+            languageServices: codeIntelligence.size,
         });
     };
     const transportCleanupTimer = setInterval(() => {
@@ -2276,7 +2295,7 @@ export function createServer(config = loadConfig(), options = {}) {
                         });
                     }
                 };
-                const server = createMcpServer(config, workspaces, reviewCheckpoints, processSessions, localAgentProviders, incomingArtifactAdapters);
+                const server = createMcpServer(config, workspaces, reviewCheckpoints, processSessions, localAgentProviders, incomingArtifactAdapters, codeIntelligence);
                 await server.connect(transport);
             }
             else {
@@ -2306,6 +2325,7 @@ export function createServer(config = loadConfig(), options = {}) {
                 const results = await transports.closeAll();
                 logTransportCloseResults("server_shutdown", results);
                 processSessions.shutdown();
+                await codeIntelligence.shutdown();
                 oauthProvider.close();
                 workspaceStore.close?.();
             })();

package/docs/configuration.md

@@ -151,6 +151,71 @@ snapshot, treat that as stale Host MCP metadata: reconnect/refresh the integrati
 or use a Host context that reloads `tools/list`. The ForgeRelay process cannot
 force a Host to invalidate its cached schema.
 
+### LSP code intelligence
+
+ForgeRelay advertises `code.intelligence` through the Capability Gateway; it does
+not add language-specific top-level MCP tools. ForgeRelay 0.4.1 supports
+`definition` and `hover`. Both operations accept the same workspace-relative source
+position. Hover results normalize plaintext, Markdown, and supported legacy LSP
+payloads into one `contents` string with optional `language` and normalized `range`
+metadata. Language Servers are external dependencies: ForgeRelay may discover an
+executable already installed on the machine, but it never downloads or installs one
+automatically.
+
+Effective Language-server definitions resolve in this order:
+
+1. project configuration in `.forgerelay/language-servers.json`;
+2. global definitions from the `languageServers` object in
+   `~/.forgerelay/config.json`;
+3. built-in discovery for known executables.
+
+A project configuration file is an object keyed by definition name. Definitions
+use structured process launch and never go through a shell:
+
+```json
+{
+  "typescript": {
+    "command": "typescript-language-server",
+    "args": ["--stdio"],
+    "env": {},
+    "languages": ["typescript", "typescriptreact", "javascript", "javascriptreact"],
+    "extensions": [".ts", ".tsx", ".js", ".jsx"],
+    "languageIdByExtension": {
+      ".ts": "typescript",
+      ".tsx": "typescriptreact",
+      ".js": "javascript",
+      ".jsx": "javascriptreact"
+    },
+    "projectMarkers": ["tsconfig.json", "jsconfig.json"]
+  }
+}
+```
+
+Global configuration uses the same definition shape under `languageServers`:
+
+```json
+{
+  "languageServers": {
+    "typescript": {
+      "command": "/absolute/path/to/typescript-language-server",
+      "args": ["--stdio"]
+    }
+  }
+}
+```
+
+Explicit configuration can set `"enabled": false` to suppress the matching
+built-in definition. Project values override global values, and both override
+built-in defaults. ForgeRelay resolves a Language project by walking ancestors of
+the requested source file according to that definition's `projectMarkers`; it does
+not recursively scan the Workspace.
+
+Code-intelligence input positions are 1-based line and 1-based Unicode code-point
+column values. The Workspace filesystem is the only v1 document source of truth.
+Definition results may point outside the Workspace and are then marked
+`external: true`; this is informational only and does not expand allowed roots or
+file-tool authority.
+
 `rename` is the canonical move/rename primitive for files and directories; there
 is no separate `move` MCP tool.
 

package/docs/roadmap.md

@@ -225,6 +225,21 @@ Candidate servers include `typescript-language-server`/tsserver, Pyright,
 `rust-analyzer`, `gopls`, and `clangd`, but ForgeRelay should treat server
 commands/configuration as external dependencies.
 
+0.4 is delivered as independently published patch releases rather than one large
+0.4.0 batch. Every boundary must complete local acceptance, update release metadata,
+create and push its matching tag, pass cloud CI, publish npm and the GitHub Release,
+and verify publication before work begins on the next boundary:
+
+- **0.4.0** — Language-service foundation plus the complete `definition` tracer bullet;
+- **0.4.1** — hover/type information;
+- **0.4.2** — references and bounded semantic-location results;
+- **0.4.3** — hierarchical document symbols and bounded workspace symbols;
+- **0.4.4** — push/pull diagnostics and Diagnostic snapshots;
+- **0.4.5** — cancellation, deadlines, crash recovery/config invalidation, concurrency,
+  and full Language-service resource/lifecycle hardening;
+- **0.4.6** — optional real-server interoperability, cross-platform checks, fresh Host
+  acceptance, documentation, and final LSP v1 closure.
+
 ## 0.5 — First-class subagent MCP
 
 ForgeRelay already owns provider adapters and resumable local agent sessions.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akira-tl/forgerelay",
-  "version": "0.3.7",
+  "version": "0.4.1",
   "description": "Local development control plane for MCP coding agents.",
   "type": "module",
   "homepage": "https://github.com/Akira-TL/forgerelay#readme",
@@ -42,7 +42,7 @@
     "debug:accept": "node scripts/debug/accept.mjs",
     "postinstall": "node scripts/fix-node-pty-permissions.mjs",
     "start": "node dist/cli.js serve",
-    "test": "tsx src/config.test.ts && tsx src/logger.test.ts && tsx src/proxy-trust.test.ts && tsx src/mcp-app-template.test.ts && tsx src/hooks.test.ts && tsx src/capability-registry.test.ts && tsx src/mcp/server-instructions.test.ts && tsx src/request-meta.test.ts && tsx src/incoming-artifacts.test.ts && tsx src/artifact-download.test.ts && tsx src/ui/card-types.test.ts && tsx src/ui/patch-display.test.ts && tsx src/ui/tool-display.test.ts && tsx src/apply-patch.test.ts && tsx src/process-platform.test.ts && tsx src/process-sessions.test.ts && tsx src/mcp-sessions.test.ts && tsx src/server-shutdown.test.ts && tsx src/local-agent-runtime.test.ts && tsx src/local-agent-adapters.test.ts && tsx src/local-agent-availability.test.ts && tsx src/local-agent-profiles.test.ts && tsx src/local-agent-targets.test.ts && tsx src/local-agent-store.test.ts && tsx src/roots.test.ts && tsx src/file-mutations.test.ts && tsx src/skills.test.ts && tsx src/workspace-store.test.ts && tsx src/workspaces.test.ts && tsx src/workspace-conversation.test.ts && tsx src/review-checkpoints.test.ts && tsx src/server.test.ts && tsx src/oauth-store.test.ts && tsx src/cli.test.ts",
+    "test": "tsx src/config.test.ts && tsx src/lsp/language-server-config.test.ts && tsx src/lsp/normalization/hover.test.ts && tsx src/logger.test.ts && tsx src/proxy-trust.test.ts && tsx src/mcp-app-template.test.ts && tsx src/hooks.test.ts && tsx src/capability-registry.test.ts && tsx src/mcp/server-instructions.test.ts && tsx src/request-meta.test.ts && tsx src/incoming-artifacts.test.ts && tsx src/artifact-download.test.ts && tsx src/ui/card-types.test.ts && tsx src/ui/patch-display.test.ts && tsx src/ui/tool-display.test.ts && tsx src/apply-patch.test.ts && tsx src/process-platform.test.ts && tsx src/process-sessions.test.ts && tsx src/mcp-sessions.test.ts && tsx src/server-shutdown.test.ts && tsx src/local-agent-runtime.test.ts && tsx src/local-agent-adapters.test.ts && tsx src/local-agent-availability.test.ts && tsx src/local-agent-profiles.test.ts && tsx src/local-agent-targets.test.ts && tsx src/local-agent-store.test.ts && tsx src/roots.test.ts && tsx src/file-mutations.test.ts && tsx src/skills.test.ts && tsx src/workspace-store.test.ts && tsx src/workspaces.test.ts && tsx src/workspace-conversation.test.ts && tsx src/review-checkpoints.test.ts && tsx src/lsp/code-intelligence.server.test.ts && tsx src/server.test.ts && tsx src/oauth-store.test.ts && tsx src/cli.test.ts",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "release:check": "node scripts/release-version.mjs check",
     "release:tag-check": "node scripts/release-version.mjs tag",
@@ -79,6 +79,8 @@
     "react": "^19.2.6",
     "react-dom": "^19.2.6",
     "semver": "^7.8.4",
+    "vscode-jsonrpc": "^9.0.1",
+    "vscode-languageserver-protocol": "^3.18.2",
     "yaml": "^2.9.0",
     "zod": "^4.4.3"
   },

package/scripts/debug/accept.mjs

@@ -244,6 +244,7 @@ try {
       "process.lifecycle",
       "hooks.lifecycle",
       "capability-guides.read",
+      "code.intelligence",
       ...(process.platform === "linux" ? ["artifact.native-download"] : []),
       "ui.mcp-app",
       "review.changes",
@@ -253,6 +254,7 @@ try {
   assert.deepEqual(capabilityCatalog.map((entry) => entry.name), [
     "hooks.check",
     "review.changes",
+    "code.intelligence",
     ...(process.platform === "linux" ? ["artifact.download"] : []),
   ]);
   assert.equal(capabilityCatalog[0].available, true);
@@ -323,6 +325,18 @@ try {
   assert.equal(describedCapability.isError, undefined);
   assert.equal(describedCapability.structuredContent.capability.guide.name, "lifecycle-hooks");
   assert.equal(describedCapability.structuredContent.capability.inputSchema.type, "object");
+  const describedCodeIntelligence = callTool(oauth.accessToken, sessionId, 88, "capability", {
+    workspaceId,
+    name: "code.intelligence",
+    action: "describe",
+  });
+  assert.equal(describedCodeIntelligence.isError, undefined);
+  assert.equal(describedCodeIntelligence.structuredContent.capability.guide.name, "code-intelligence");
+  assert.equal(describedCodeIntelligence.structuredContent.capability.inputSchema.type, "object");
+  assert.deepEqual(
+    describedCodeIntelligence.structuredContent.capability.inputSchema.properties.operation.enum,
+    ["definition", "hover"],
+  );
   if (process.platform === "linux") {
     const describedArtifact = callTool(oauth.accessToken, sessionId, 82, "capability", {
       workspaceId,
@@ -350,6 +364,7 @@ try {
     "artifacts-review",
     "host-integration",
     "shell-processes",
+    "code-intelligence",
   ]);
   const hooksGuide = callTool(oauth.accessToken, sessionId, 78, "read", {
     workspaceId,