@cjhyy/code-shell-core 0.7.1 → 0.8.1

package/dist/git/worktree/query.d.ts

@@ -1,43 +0,0 @@
-import type { SessionWorkspace } from "../../types.js";
-import { type WorktreeDiffSummary } from "./diff.js";
-export interface WorktreeWorkspaceOwner {
-    sessionId: string;
-    workspace?: SessionWorkspace;
-}
-export interface ListWorktreesFastOptions {
-    currentSessionId?: string;
-    workspaceOwners?: WorktreeWorkspaceOwner[];
-    owners?: WorktreeWorkspaceOwner[];
-    prefix?: string;
-    signal?: AbortSignal;
-}
-export interface ListWorktreesOptions extends ListWorktreesFastOptions {
-    includeDiffSummary?: boolean;
-}
-export interface WorktreeInfo {
-    path: string;
-    branch: string;
-    head: string;
-    isMain?: boolean;
-    isManaged?: boolean;
-    diff?: WorktreeDiffSummary;
-    occupiedBySessionIds?: string[];
-    occupiedByOtherSession?: boolean;
-}
-/**
- * Find the canonical git root (resolves worktree -> main repo).
- */
-export declare function findGitRoot(cwd: string, signal?: AbortSignal): Promise<string>;
-export declare function findMainWorktreeRoot(cwd: string, signal?: AbortSignal): Promise<string>;
-export declare function findWorktreeForBranch(cwd: string, branch: string, signal?: AbortSignal): Promise<string | undefined>;
-export declare function assertBranchNotCheckedOut(cwd: string, branch: string, signal?: AbortSignal): Promise<void>;
-export declare function branchExists(cwd: string, branch: string, signal?: AbortSignal): Promise<boolean>;
-export declare function isGitWorktreeRoot(cwd: string, signal?: AbortSignal): Promise<boolean>;
-export declare function currentBranch(cwd: string, signal?: AbortSignal): Promise<string | undefined>;
-export declare function listWorktreesFast(cwd: string, opts?: ListWorktreesFastOptions): Promise<WorktreeInfo[]>;
-/**
- * List active worktrees. Kept for internal/test compatibility; use
- * listWorktreesFast for UI lists that should not block on diff work.
- */
-export declare function listWorktrees(cwd: string, opts?: ListWorktreesOptions): Promise<WorktreeInfo[]>;
-export declare function ownersForWorktree(path: string, owners: WorktreeWorkspaceOwner[]): string[];

package/dist/git/worktree/query.js

@@ -1,128 +0,0 @@
-import { existsSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { getWorktreeDiff } from "./diff.js";
-import { execGit, gitOutput, normalizeBranchName } from "./git-exec.js";
-import { isManagedWorktreeBranch } from "./slug.js";
-/**
- * Find the canonical git root (resolves worktree -> main repo).
- */
-export async function findGitRoot(cwd, signal) {
-    return await findMainWorktreeRoot(cwd, signal);
-}
-export async function findMainWorktreeRoot(cwd, signal) {
-    const commonDir = (await execGit(cwd, ["rev-parse", "--path-format=absolute", "--git-common-dir"], 5000, signal)).trim();
-    return dirname(commonDir);
-}
-export async function findWorktreeForBranch(cwd, branch, signal) {
-    const normalized = normalizeBranchName(branch);
-    return (await listWorktreesFast(cwd, { signal })).find((entry) => entry.branch === normalized)
-        ?.path;
-}
-export async function assertBranchNotCheckedOut(cwd, branch, signal) {
-    const existingPath = await findWorktreeForBranch(cwd, branch, signal);
-    if (existingPath) {
-        throw new Error(`branch ${normalizeBranchName(branch)} already checked out at ${existingPath}`);
-    }
-}
-export async function branchExists(cwd, branch, signal) {
-    const out = await gitOutput(cwd, ["branch", "--list", normalizeBranchName(branch)], 10000, signal);
-    return (out?.trim().length ?? 0) > 0;
-}
-export async function isGitWorktreeRoot(cwd, signal) {
-    if (!existsSync(join(cwd, ".git")))
-        return false;
-    try {
-        const inside = (await execGit(cwd, ["rev-parse", "--is-inside-work-tree"], 5000, signal)).trim();
-        if (inside !== "true")
-            return false;
-        const topLevel = (await execGit(cwd, ["rev-parse", "--path-format=absolute", "--show-toplevel"], 5000, signal)).trim();
-        return resolve(topLevel) === resolve(cwd);
-    }
-    catch (error) {
-        if (signal?.aborted)
-            throw error;
-        return false;
-    }
-}
-export async function currentBranch(cwd, signal) {
-    const branch = (await gitOutput(cwd, ["branch", "--show-current"], 5000, signal))?.trim();
-    return branch || undefined;
-}
-export async function listWorktreesFast(cwd, opts = {}) {
-    let raw;
-    try {
-        raw = (await execGit(cwd, ["worktree", "list", "--porcelain"], 10000, opts.signal)).trim();
-    }
-    catch (error) {
-        if (opts.signal?.aborted)
-            throw error;
-        return [];
-    }
-    if (!raw)
-        return [];
-    const entries = [];
-    let current = { path: "", branch: "", head: "" };
-    for (const line of raw.split("\n")) {
-        if (line.startsWith("worktree ")) {
-            if (current.path)
-                entries.push(current);
-            current = { path: line.slice(9), branch: "", head: "" };
-        }
-        else if (line.startsWith("HEAD ")) {
-            current.head = line.slice(5, 13);
-        }
-        else if (line.startsWith("branch ")) {
-            current.branch = normalizeBranchName(line.slice(7));
-        }
-    }
-    if (current.path)
-        entries.push(current);
-    let mainRoot = "";
-    try {
-        mainRoot = await findMainWorktreeRoot(cwd, opts.signal);
-    }
-    catch (error) {
-        if (opts.signal?.aborted)
-            throw error;
-        mainRoot = entries[0]?.path ?? "";
-    }
-    const owners = opts.workspaceOwners ?? opts.owners ?? [];
-    return entries.map((entry) => {
-        const ownerIds = ownersForWorktree(entry.path, owners);
-        return {
-            ...entry,
-            ...(mainRoot ? { isMain: resolve(entry.path) === resolve(mainRoot) } : {}),
-            isManaged: Boolean(entry.branch) && isManagedWorktreeBranch(entry.branch, opts.prefix),
-            ...(ownerIds.length > 0
-                ? {
-                    occupiedBySessionIds: ownerIds,
-                    occupiedByOtherSession: ownerIds.some((id) => id !== opts.currentSessionId),
-                }
-                : {}),
-        };
-    });
-}
-/**
- * List active worktrees. Kept for internal/test compatibility; use
- * listWorktreesFast for UI lists that should not block on diff work.
- */
-export async function listWorktrees(cwd, opts = {}) {
-    const entries = await listWorktreesFast(cwd, opts);
-    if (!opts.includeDiffSummary)
-        return entries;
-    return Promise.all(entries.map(async (entry) => ({
-        ...entry,
-        diff: await getWorktreeDiff(entry.path),
-    })));
-}
-export function ownersForWorktree(path, owners) {
-    const target = resolve(path);
-    return owners
-        .filter((owner) => {
-        const workspace = owner.workspace;
-        if (!workspace)
-            return false;
-        return resolve(workspace.root) === target;
-    })
-        .map((owner) => owner.sessionId);
-}

package/dist/git/worktree/slug.d.ts

@@ -1,11 +0,0 @@
-export declare const DEFAULT_WORKTREE_BRANCH_PREFIX = "worktree/";
-export declare const HISTORICAL_WORKTREE_BRANCH_PREFIX = "worktree/";
-/**
- * Validate worktree slug to prevent path traversal attacks.
- */
-export declare function validateWorktreeSlug(slug: string): void;
-export declare function normalizeWorktreeBranchPrefix(prefix?: string | undefined): string;
-export declare function isValidWorktreeBranchPrefix(prefix: string): boolean;
-export declare function applyPrefix(prefix: string | undefined, slug: string, sessionId: string): string;
-export declare function managedBranchPrefixes(prefix?: string): string[];
-export declare function isManagedWorktreeBranch(branch: string, prefix?: string): boolean;

package/dist/git/worktree/slug.js

@@ -1,58 +0,0 @@
-export const DEFAULT_WORKTREE_BRANCH_PREFIX = "worktree/";
-export const HISTORICAL_WORKTREE_BRANCH_PREFIX = "worktree/";
-/**
- * Validate worktree slug to prevent path traversal attacks.
- */
-export function validateWorktreeSlug(slug) {
-    if (slug.trim().length === 0)
-        throw new Error("Worktree slug cannot be empty");
-    if (slug.length > 64)
-        throw new Error("Worktree slug too long (max 64 chars)");
-    if (/[^a-zA-Z0-9._-]/.test(slug))
-        throw new Error("Worktree slug contains invalid characters");
-    if (slug.startsWith(".") || slug.includes(".."))
-        throw new Error("Worktree slug cannot start with '.' or contain '..'");
-}
-export function normalizeWorktreeBranchPrefix(prefix = DEFAULT_WORKTREE_BRANCH_PREFIX) {
-    const raw = (prefix ?? DEFAULT_WORKTREE_BRANCH_PREFIX).trim();
-    if (!isValidWorktreeBranchPrefix(raw)) {
-        throw new Error(`Invalid worktree branch prefix: ${prefix ?? ""}`);
-    }
-    return raw.endsWith("/") ? raw : `${raw}/`;
-}
-export function isValidWorktreeBranchPrefix(prefix) {
-    const raw = prefix.trim();
-    if (!raw)
-        return false;
-    if (raw.startsWith("/") || raw.includes("//"))
-        return false;
-    if (raw.includes("..") || raw.includes("@{"))
-        return false;
-    if (/[\x00-\x20~^:?*[\]\\]/.test(raw))
-        return false;
-    const withoutTrailingSlash = raw.endsWith("/") ? raw.slice(0, -1) : raw;
-    if (!withoutTrailingSlash)
-        return false;
-    return withoutTrailingSlash.split("/").every((part) => {
-        if (!part)
-            return false;
-        if (part.startsWith(".") || part.endsWith("."))
-            return false;
-        if (part.endsWith(".lock"))
-            return false;
-        return true;
-    });
-}
-export function applyPrefix(prefix, slug, sessionId) {
-    validateWorktreeSlug(slug);
-    return `${normalizeWorktreeBranchPrefix(prefix)}${slug}-${sessionId.slice(0, 8)}`;
-}
-export function managedBranchPrefixes(prefix) {
-    const configured = normalizeWorktreeBranchPrefix(prefix);
-    return configured === HISTORICAL_WORKTREE_BRANCH_PREFIX
-        ? [configured]
-        : [configured, HISTORICAL_WORKTREE_BRANCH_PREFIX];
-}
-export function isManagedWorktreeBranch(branch, prefix) {
-    return managedBranchPrefixes(prefix).some((candidate) => branch.startsWith(candidate));
-}

package/dist/git/worktree.d.ts

@@ -1 +0,0 @@
-export * from "./worktree/index.js";

package/dist/git/worktree.js

@@ -1,5 +0,0 @@
-// Compatibility barrel for the pre-split worktree module. The split made the
-// query/create APIs async because they now share the async git executor; all
-// in-repo callers await them, so this barrel intentionally does not add sync
-// wrappers.
-export * from "./worktree/index.js";

package/dist/lsp/client.d.ts

@@ -1,41 +0,0 @@
-/**
- * LSP client — JSON-RPC over stdio communication with language servers.
- */
-import { EventEmitter } from "node:events";
-export interface LSPRequest {
-    method: string;
-    params?: Record<string, unknown>;
-}
-export interface LSPResponse {
-    id: number;
-    result?: unknown;
-    error?: {
-        code: number;
-        message: string;
-    };
-}
-export interface LSPNotification {
-    method: string;
-    params?: Record<string, unknown>;
-}
-export declare class LSPClient extends EventEmitter {
-    private readonly command;
-    private readonly args;
-    private readonly cwd?;
-    private process;
-    private nextId;
-    private pending;
-    private buffer;
-    private contentLength;
-    private initialized;
-    constructor(command: string, args?: string[], cwd?: string | undefined);
-    start(): Promise<void>;
-    initialize(rootUri: string): Promise<unknown>;
-    request(method: string, params?: Record<string, unknown>): Promise<unknown>;
-    notify(method: string, params?: Record<string, unknown>): Promise<void>;
-    shutdown(): Promise<void>;
-    get isInitialized(): boolean;
-    get isAlive(): boolean;
-    private handleData;
-    private rejectAll;
-}

package/dist/lsp/client.js

@@ -1,186 +0,0 @@
-/**
- * LSP client — JSON-RPC over stdio communication with language servers.
- */
-import { spawn } from "node:child_process";
-import { EventEmitter } from "node:events";
-export class LSPClient extends EventEmitter {
-    command;
-    args;
-    cwd;
-    process;
-    nextId = 1;
-    pending = new Map();
-    // The LSP framing uses byte-counted Content-Length, so we buffer bytes,
-    // not characters. Joining chunks as strings (`data.toString()` + string
-    // concat) can split a multibyte UTF-8 codepoint across chunks and de-
-    // synchronize against Content-Length. Stay in Buffer-land until we've
-    // sliced out exactly the right body length.
-    buffer = Buffer.alloc(0);
-    contentLength = -1;
-    initialized = false;
-    constructor(command, args = [], cwd) {
-        super();
-        this.command = command;
-        this.args = args;
-        this.cwd = cwd;
-    }
-    async start() {
-        this.process = spawn(this.command, this.args, {
-            cwd: this.cwd,
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        this.process.stdout?.on("data", (data) => this.handleData(data));
-        this.process.stderr?.on("data", (_data) => {
-            // LSP servers often log to stderr — ignore
-        });
-        this.process.on("exit", (code) => {
-            this.emit("exit", code);
-            this.rejectAll(new Error(`LSP server exited with code ${code}`));
-        });
-        // Don't keep the event loop alive solely for the LSP child.
-        // Call after listeners are wired so event registration doesn't re-ref.
-        this.process.unref();
-    }
-    async initialize(rootUri) {
-        const result = await this.request("initialize", {
-            processId: process.pid,
-            rootUri,
-            capabilities: {
-                textDocument: {
-                    definition: { dynamicRegistration: false },
-                    references: { dynamicRegistration: false },
-                    hover: { contentFormat: ["plaintext", "markdown"] },
-                    documentSymbol: { dynamicRegistration: false },
-                    completion: { dynamicRegistration: false },
-                },
-                workspace: {
-                    symbol: { dynamicRegistration: false },
-                },
-            },
-        });
-        await this.notify("initialized", {});
-        this.initialized = true;
-        return result;
-    }
-    async request(method, params) {
-        if (!this.process?.stdin)
-            throw new Error("LSP server not started");
-        const id = this.nextId++;
-        const message = { jsonrpc: "2.0", id, method, params };
-        const content = JSON.stringify(message);
-        const header = `Content-Length: ${Buffer.byteLength(content)}\r\n\r\n`;
-        return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                if (this.pending.has(id)) {
-                    this.pending.delete(id);
-                    reject(new Error(`LSP request "${method}" timed out`));
-                }
-            }, 30000);
-            // Don't let the timer keep the event loop alive by itself
-            timer.unref?.();
-            this.pending.set(id, {
-                resolve: (value) => { clearTimeout(timer); resolve(value); },
-                reject: (err) => { clearTimeout(timer); reject(err); },
-            });
-            this.process.stdin.write(header + content);
-        });
-    }
-    async notify(method, params) {
-        if (!this.process?.stdin)
-            throw new Error("LSP server not started");
-        const message = { jsonrpc: "2.0", method, params };
-        const content = JSON.stringify(message);
-        const header = `Content-Length: ${Buffer.byteLength(content)}\r\n\r\n`;
-        this.process.stdin.write(header + content);
-    }
-    async shutdown() {
-        if (!this.process)
-            return;
-        try {
-            await this.request("shutdown", {});
-            await this.notify("exit", {});
-        }
-        catch {
-            // Force kill
-        }
-        this.process.stdout?.removeAllListeners();
-        this.process.stderr?.removeAllListeners();
-        this.process.removeAllListeners();
-        this.process.kill();
-        this.process = undefined;
-        // Drain pending requests
-        for (const { reject } of this.pending.values()) {
-            reject(new Error("LSP server shut down"));
-        }
-        this.pending.clear();
-    }
-    get isInitialized() {
-        return this.initialized;
-    }
-    get isAlive() {
-        return this.process !== undefined && !this.process.killed;
-    }
-    handleData(data) {
-        // Append the new chunk as bytes. Buffer.concat avoids the UTF-8
-        // boundary corruption that string concatenation produces — a
-        // multibyte codepoint split across two TCP/pipe chunks decodes to
-        // U+FFFD, mangles the buffer length count, and breaks framing.
-        this.buffer = Buffer.concat([this.buffer, data]);
-        while (true) {
-            if (this.contentLength < 0) {
-                // Search for the header terminator in bytes, not chars.
-                const headerEnd = this.buffer.indexOf("\r\n\r\n");
-                if (headerEnd < 0)
-                    break;
-                // Headers are ASCII per spec, so toString("ascii") is safe and
-                // avoids paying for a UTF-8 decode on the framing band.
-                const header = this.buffer.slice(0, headerEnd).toString("ascii");
-                const match = header.match(/Content-Length:\s*(\d+)/i);
-                if (!match) {
-                    this.buffer = this.buffer.subarray(headerEnd + 4);
-                    continue;
-                }
-                this.contentLength = parseInt(match[1], 10);
-                this.buffer = this.buffer.subarray(headerEnd + 4);
-            }
-            // Content-Length is a BYTE count — compare against the buffer's
-            // byte length, not its character length. Pre-fix this compared
-            // string lengths; with multibyte responses (e.g. CJK identifiers,
-            // emoji in diagnostics) we'd block waiting for bytes that had
-            // already arrived.
-            if (this.buffer.length < this.contentLength)
-                break;
-            const bodyBytes = this.buffer.subarray(0, this.contentLength);
-            this.buffer = this.buffer.subarray(this.contentLength);
-            this.contentLength = -1;
-            // Decode the full body in one shot — at this point we have the
-            // exact byte count, so the UTF-8 boundary issue is fully gone.
-            const content = bodyBytes.toString("utf8");
-            try {
-                const message = JSON.parse(content);
-                if ("id" in message && this.pending.has(message.id)) {
-                    const { resolve, reject } = this.pending.get(message.id);
-                    this.pending.delete(message.id);
-                    if (message.error) {
-                        reject(new Error(`LSP error: ${message.error.message}`));
-                    }
-                    else {
-                        resolve(message.result);
-                    }
-                }
-                else if ("method" in message && !("id" in message)) {
-                    this.emit("notification", message);
-                }
-            }
-            catch {
-                // Skip malformed messages
-            }
-        }
-    }
-    rejectAll(error) {
-        for (const { reject } of this.pending.values()) {
-            reject(error);
-        }
-        this.pending.clear();
-    }
-}

package/dist/lsp/manager.d.ts

@@ -1,40 +0,0 @@
-/**
- * LSP Server Manager — manages lifecycle of language server instances.
- * Lazy initialization: servers start only when needed.
- */
-import { LSPClient } from "./client.js";
-type ServerState = "stopped" | "starting" | "ready" | "error";
-export declare class LSPServerManager {
-    private servers;
-    private rootUri;
-    constructor(cwd: string);
-    /**
-     * Get or start a language server by name.
-     */
-    getClient(serverName: string): Promise<LSPClient | undefined>;
-    /**
-     * Start a specific language server.
-     */
-    private startServer;
-    /**
-     * Check if any LSP server is connected.
-     */
-    isConnected(): boolean;
-    /**
-     * List server statuses.
-     */
-    listServers(): Array<{
-        name: string;
-        language: string;
-        state: ServerState;
-        error?: string;
-    }>;
-    /**
-     * Shutdown all servers.
-     */
-    shutdownAll(): Promise<void>;
-}
-export declare function isCommandAvailable(command: string, env?: NodeJS.ProcessEnv): boolean;
-export declare function initializeLSPManager(cwd: string): LSPServerManager;
-export declare function getLSPManager(): LSPServerManager | undefined;
-export {};

package/dist/lsp/manager.js

@@ -1,155 +0,0 @@
-/**
- * LSP Server Manager — manages lifecycle of language server instances.
- * Lazy initialization: servers start only when needed.
- */
-import { LSPClient } from "./client.js";
-import { BUILTIN_LSP_SERVERS } from "./servers.js";
-import { accessSync, constants, statSync } from "node:fs";
-import { delimiter, join } from "node:path";
-import { pathToFileURL } from "node:url";
-import { rootUriToPath } from "./root-path.js";
-import { commandCandidateNames } from "../utils/exec.js";
-export class LSPServerManager {
-    servers = new Map();
-    rootUri;
-    constructor(cwd) {
-        this.rootUri = pathToFileURL(cwd).href;
-        // Register all built-in servers
-        for (const config of BUILTIN_LSP_SERVERS) {
-            this.servers.set(config.name, { config, client: undefined, state: "stopped" });
-        }
-    }
-    /**
-     * Get or start a language server by name.
-     */
-    async getClient(serverName) {
-        const managed = this.servers.get(serverName);
-        if (!managed)
-            return undefined;
-        if (managed.state === "ready" && managed.client?.isAlive) {
-            return managed.client;
-        }
-        if (managed.state === "starting") {
-            // Wait for it to be ready
-            await new Promise((r) => setTimeout(r, 2000));
-            return managed.client;
-        }
-        // Try to start
-        return this.startServer(serverName);
-    }
-    /**
-     * Start a specific language server.
-     */
-    async startServer(name) {
-        const managed = this.servers.get(name);
-        if (!managed)
-            return undefined;
-        // Check if command is available
-        if (!isCommandAvailable(managed.config.command)) {
-            managed.state = "error";
-            managed.error = `${managed.config.command} not found. Install: ${managed.config.installHint}`;
-            return undefined;
-        }
-        managed.state = "starting";
-        try {
-            const client = new LSPClient(managed.config.command, managed.config.args, rootUriToPath(this.rootUri));
-            await client.start();
-            await client.initialize(this.rootUri);
-            managed.client = client;
-            managed.state = "ready";
-            return client;
-        }
-        catch (err) {
-            managed.state = "error";
-            managed.error = err.message;
-            return undefined;
-        }
-    }
-    /**
-     * Check if any LSP server is connected.
-     */
-    isConnected() {
-        for (const server of this.servers.values()) {
-            if (server.state === "ready" && server.client?.isAlive)
-                return true;
-        }
-        return false;
-    }
-    /**
-     * List server statuses.
-     */
-    listServers() {
-        return [...this.servers.values()].map((s) => ({
-            name: s.config.name,
-            language: s.config.language,
-            state: s.state,
-            error: s.error,
-        }));
-    }
-    /**
-     * Shutdown all servers.
-     */
-    async shutdownAll() {
-        for (const server of this.servers.values()) {
-            if (server.client?.isAlive) {
-                try {
-                    await server.client.shutdown();
-                }
-                catch {
-                    // Force killed
-                }
-            }
-            server.state = "stopped";
-            server.client = undefined;
-        }
-    }
-}
-export function isCommandAvailable(command, env = process.env) {
-    const trimmed = command.trim();
-    if (!trimmed)
-        return false;
-    const hasPathSeparator = trimmed.includes("/") || trimmed.includes("\\");
-    // A bare command with whitespace is not executable via spawn(command, args)
-    // anyway. Reject it up front so a configured command can never be interpreted
-    // as shell syntax such as `pylsp; touch /tmp/pwned`.
-    if (!hasPathSeparator && /\s/.test(trimmed))
-        return false;
-    if (hasPathSeparator) {
-        return candidateCommandNames(trimmed, env).some(isExecutableFile);
-    }
-    for (const dir of (env.PATH ?? "").split(delimiter)) {
-        if (!dir)
-            continue;
-        for (const name of candidateCommandNames(trimmed, env)) {
-            if (isExecutableFile(join(dir, name)))
-                return true;
-        }
-    }
-    return false;
-}
-function candidateCommandNames(command, env) {
-    return commandCandidateNames(command, env);
-}
-function isExecutableFile(filePath) {
-    try {
-        const st = statSync(filePath);
-        if (!st.isFile())
-            return false;
-        if (process.platform !== "win32") {
-            accessSync(filePath, constants.X_OK);
-        }
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-// Singleton
-let _manager;
-export function initializeLSPManager(cwd) {
-    _manager = new LSPServerManager(cwd);
-    return _manager;
-}
-export function getLSPManager() {
-    return _manager;
-}

package/dist/lsp/root-path.d.ts

@@ -1,9 +0,0 @@
-/**
- * Convert a `file://` root URI to a platform filesystem path.
- *
- * The LSP manager used `rootUri.replace("file://", "")`, which only strips the
- * first occurrence and leaves percent-encoding intact, and on Windows turns
- * `file:///C:/x` into the invalid `/C:/x`. fileURLToPath does the proper
- * platform conversion (drive letters, percent-decoding, UNC).
- */
-export declare function rootUriToPath(rootUri: string): string;