@easonwumac/computer-linker 0.1.2

package/dist/screenshot.js

@@ -0,0 +1,302 @@
+import { execFile } from "node:child_process";
+import { mkdir, readFile, rename, rm } from "node:fs/promises";
+import { platform, tmpdir } from "node:os";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { promisify } from "node:util";
+import { executableCommand, findExecutableCommand, windowsVerbatimArgumentsOption } from "./platform-shell.js";
+const execFileAsync = promisify(execFile);
+const windowsScreenshotCommandEnv = "COMPUTER_LINKER_WINDOWS_SCREENSHOT_COMMAND";
+const legacyWindowsScreenshotCommandEnv = "WORKSPACE_LINKER_WINDOWS_SCREENSHOT_COMMAND";
+export function screenshotCapability() {
+    const provider = screenshotProvider();
+    if (!provider.available) {
+        return {
+            permission: provider.permission,
+            provider: provider.name,
+            supported: false,
+            modes: [],
+            displays: [],
+            windows: [],
+        };
+    }
+    return {
+        permission: provider.permission,
+        provider: provider.name,
+        supported: true,
+        modes: provider.modes,
+        displays: [{ id: "primary", primary: true }],
+        windows: [],
+    };
+}
+export function listScreenshotTargets() {
+    return screenshotCapability();
+}
+export async function captureScreenshot(options) {
+    const provider = screenshotProvider();
+    if (!provider.available) {
+        throw new Error(provider.permission.detail ?? "screenshot provider is unavailable on this platform");
+    }
+    if (options.format && options.format !== "png") {
+        throw new Error("only png screenshot format is currently supported");
+    }
+    validateScreenshotBounds(options);
+    if (options.source === "process") {
+        throw new Error("screen.capture_process is not implemented for this platform provider yet");
+    }
+    if (options.source === "display" && options.target && options.target !== "primary") {
+        throw new Error("only the primary display target is currently supported");
+    }
+    if (options.source === "window" && !options.target) {
+        throw new Error("window id is required for screen.capture_window");
+    }
+    if (!provider.modes.includes(options.source)) {
+        throw new Error(`screen.${options.source} capture is not implemented for ${provider.name}`);
+    }
+    const dir = join(tmpdir(), "computer-linker-screenshots");
+    await mkdir(dir, { recursive: true });
+    const file = join(dir, `screenshot-${randomUUID()}.png`);
+    const args = provider.captureArgs(options, file);
+    try {
+        const command = executableCommand(provider.command, args);
+        await execFileAsync(command.command, command.args, {
+            timeout: 30_000,
+            windowsHide: true,
+            ...windowsVerbatimArgumentsOption(command),
+        });
+    }
+    catch (error) {
+        await rm(file, { force: true });
+        throw new Error(`screenshot capture failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    try {
+        await downscaleScreenshotIfNeeded(file, options);
+    }
+    catch (error) {
+        await rm(file, { force: true });
+        throw error;
+    }
+    const bytes = await readFile(file);
+    const dimensions = pngDimensions(bytes);
+    const returnMode = options.returnMode ?? "fileRef";
+    const result = {
+        format: "png",
+        ...dimensions,
+        sizeBytes: bytes.byteLength,
+        source: {
+            type: options.source,
+            id: options.target || "primary",
+        },
+        permission: provider.permission,
+        provider: provider.name,
+    };
+    if (returnMode === "base64" || returnMode === "bytes") {
+        result.bytesBase64 = bytes.toString("base64");
+        await rm(file, { force: true });
+        return result;
+    }
+    if (returnMode !== "fileRef") {
+        await rm(file, { force: true });
+        throw new Error("screenshot return must be one of: fileRef, base64, bytes");
+    }
+    result.fileRef = file;
+    return result;
+}
+function screenshotProvider() {
+    if (platform() === "darwin") {
+        const command = findExecutableCommand("screencapture") ?? "/usr/sbin/screencapture";
+        return {
+            name: "macos-screencapture",
+            available: true,
+            command,
+            modes: ["display", "window"],
+            permission: {
+                status: "unknown",
+                detail: "macOS may prompt for Screen Recording permission when capture is requested.",
+            },
+            captureArgs: (options, file) => options.source === "window"
+                ? ["-x", "-t", "png", "-l", String(options.target), file]
+                : ["-x", "-t", "png", file],
+        };
+    }
+    if (platform() === "win32") {
+        const command = process.env[windowsScreenshotCommandEnv]
+            ?? process.env[legacyWindowsScreenshotCommandEnv]
+            ?? findExecutableCommand("powershell")
+            ?? findExecutableCommand("powershell.exe")
+            ?? findExecutableCommand("pwsh");
+        if (!command) {
+            return {
+                name: "windows-powershell-screenshot",
+                available: false,
+                command: "",
+                modes: [],
+                permission: {
+                    status: "unsupported",
+                    detail: "Windows screenshot capture requires PowerShell or PowerShell Core on PATH.",
+                },
+                captureArgs: () => [],
+            };
+        }
+        return {
+            name: "windows-powershell-screenshot",
+            available: true,
+            command,
+            modes: ["display"],
+            permission: {
+                status: "unknown",
+                detail: "Windows desktop capture uses PowerShell and may fail in headless or non-interactive sessions.",
+            },
+            captureArgs: (_options, file) => [
+                "-NoLogo",
+                "-NoProfile",
+                "-NonInteractive",
+                "-ExecutionPolicy",
+                "Bypass",
+                "-Command",
+                powershellScriptBlock(windowsDisplayCaptureScript()),
+                file,
+            ],
+        };
+    }
+    return {
+        name: `${platform()}-screenshot`,
+        available: false,
+        command: "",
+        modes: [],
+        permission: {
+            status: "unsupported",
+            detail: `screenshot capture provider is not implemented for ${platform()} yet`,
+        },
+        captureArgs: () => [],
+    };
+}
+async function downscaleScreenshotIfNeeded(file, options) {
+    if (!options.maxWidth && !options.maxHeight)
+        return;
+    const dimensions = pngDimensions(await readFile(file));
+    if (!dimensions.width || !dimensions.height) {
+        throw new Error("unable to determine PNG dimensions for screenshot downscaling");
+    }
+    const target = downscaledDimensions(dimensions.width, dimensions.height, options);
+    if (target.width === dimensions.width && target.height === dimensions.height) {
+        return;
+    }
+    const tempFile = join(tmpdir(), "computer-linker-screenshots", `screenshot-resized-${randomUUID()}.png`);
+    try {
+        if (platform() === "win32") {
+            await downscalePngWithPowerShell(file, tempFile, target);
+        }
+        else if (platform() === "darwin") {
+            await downscalePngWithSips(file, tempFile, target);
+        }
+        else {
+            throw new Error(`screenshot downscaling is not supported on ${platform()} yet`);
+        }
+        await rename(tempFile, file);
+    }
+    catch (error) {
+        await rm(tempFile, { force: true });
+        throw new Error(`screenshot downscaling failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function downscaledDimensions(width, height, options) {
+    const widthScale = options.maxWidth && width > options.maxWidth ? options.maxWidth / width : 1;
+    const heightScale = options.maxHeight && height > options.maxHeight ? options.maxHeight / height : 1;
+    const scale = Math.min(widthScale, heightScale);
+    return {
+        width: Math.max(1, Math.round(width * scale)),
+        height: Math.max(1, Math.round(height * scale)),
+    };
+}
+async function downscalePngWithPowerShell(file, tempFile, target) {
+    const command = findExecutableCommand("powershell")
+        ?? findExecutableCommand("powershell.exe")
+        ?? findExecutableCommand("pwsh");
+    if (!command) {
+        throw new Error("PowerShell is required for Windows screenshot downscaling");
+    }
+    const args = [
+        "-NoLogo",
+        "-NoProfile",
+        "-NonInteractive",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-Command",
+        powershellScriptBlock(windowsDownscaleScript()),
+        file,
+        tempFile,
+        String(target.width),
+        String(target.height),
+    ];
+    const executable = executableCommand(command, args);
+    await execFileAsync(executable.command, executable.args, {
+        timeout: 30_000,
+        windowsHide: true,
+        ...windowsVerbatimArgumentsOption(executable),
+    });
+}
+async function downscalePngWithSips(file, tempFile, target) {
+    const command = findExecutableCommand("sips") ?? "/usr/bin/sips";
+    await execFileAsync(command, ["-s", "format", "png", "-z", String(target.height), String(target.width), file, "--out", tempFile], {
+        timeout: 30_000,
+    });
+}
+function validateScreenshotBounds(options) {
+    for (const [label, value] of [["maxWidth", options.maxWidth], ["maxHeight", options.maxHeight]]) {
+        if (value !== undefined && (!Number.isInteger(value) || value <= 0)) {
+            throw new Error(`screenshot ${label} must be a positive integer`);
+        }
+    }
+}
+function windowsDisplayCaptureScript() {
+    return [
+        "param([string]$Path)",
+        "Add-Type -AssemblyName System.Windows.Forms",
+        "Add-Type -AssemblyName System.Drawing",
+        "$bounds = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds",
+        "$bitmap = New-Object System.Drawing.Bitmap $bounds.Width, $bounds.Height",
+        "$graphics = [System.Drawing.Graphics]::FromImage($bitmap)",
+        "try {",
+        "  $graphics.CopyFromScreen($bounds.Location, [System.Drawing.Point]::Empty, $bounds.Size)",
+        "  $bitmap.Save($Path, [System.Drawing.Imaging.ImageFormat]::Png)",
+        "} finally {",
+        "  $graphics.Dispose()",
+        "  $bitmap.Dispose()",
+        "}",
+    ].join("; ");
+}
+function powershellScriptBlock(script) {
+    return `& { ${script} }`;
+}
+function windowsDownscaleScript() {
+    return [
+        "param([string]$Path, [string]$Output, [int]$Width, [int]$Height)",
+        "Add-Type -AssemblyName System.Drawing",
+        "$image = [System.Drawing.Image]::FromFile($Path)",
+        "$bitmap = $null",
+        "$graphics = $null",
+        "try {",
+        "  $bitmap = New-Object System.Drawing.Bitmap $Width, $Height",
+        "  $graphics = [System.Drawing.Graphics]::FromImage($bitmap)",
+        "  $graphics.InterpolationMode = [System.Drawing.Drawing2D.InterpolationMode]::HighQualityBicubic",
+        "  $graphics.DrawImage($image, 0, 0, $Width, $Height)",
+        "  $bitmap.Save($Output, [System.Drawing.Imaging.ImageFormat]::Png)",
+        "} finally {",
+        "  if ($graphics -ne $null) { $graphics.Dispose() }",
+        "  if ($bitmap -ne $null) { $bitmap.Dispose() }",
+        "  $image.Dispose()",
+        "}",
+    ].join("; ");
+}
+function pngDimensions(bytes) {
+    if (bytes.byteLength >= 24 &&
+        bytes.toString("ascii", 1, 4) === "PNG" &&
+        bytes.toString("ascii", 12, 16) === "IHDR") {
+        return {
+            width: bytes.readUInt32BE(16),
+            height: bytes.readUInt32BE(20),
+        };
+    }
+    return {};
+}

package/dist/search.d.ts

@@ -0,0 +1,34 @@
+export interface SearchTextOptions {
+    cwd: string;
+    query: string;
+    glob?: string;
+    fixedStrings: boolean;
+    caseSensitive: boolean;
+    maxResults: number;
+    beforeContext?: number;
+    afterContext?: number;
+}
+export interface FindFilesOptions {
+    cwd: string;
+    pattern: string;
+    maxResults: number;
+}
+export interface SearchSymbolsOptions {
+    cwd: string;
+    query?: string;
+    glob?: string;
+    caseSensitive: boolean;
+    maxResults: number;
+    maxBytes: number;
+}
+export interface SymbolMatch {
+    path: string;
+    line: number;
+    column: number;
+    name: string;
+    kind: string;
+    signature: string;
+}
+export declare function searchText(options: SearchTextOptions): Promise<string>;
+export declare function searchSymbols(options: SearchSymbolsOptions): Promise<SymbolMatch[]>;
+export declare function findFiles(options: FindFilesOptions): Promise<string>;

package/dist/search.js

@@ -0,0 +1,340 @@
+import { execFile } from "node:child_process";
+import { opendir, readFile } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { promisify } from "node:util";
+import { isSensitiveWorkspacePath, sensitiveFileRgGlobArgs } from "./sensitive-files.js";
+const execFileAsync = promisify(execFile);
+export async function searchText(options) {
+    const args = [
+        "--line-number",
+        "--color",
+        "never",
+        "--path-separator",
+        "/",
+        "--hidden",
+        "--glob",
+        "!{.git,node_modules,dist,build,.next,.cache}/**",
+    ];
+    if (options.fixedStrings)
+        args.push("--fixed-strings");
+    if (!options.caseSensitive)
+        args.push("--ignore-case");
+    if (options.beforeContext && options.beforeContext > 0)
+        args.push("--before-context", String(options.beforeContext));
+    if (options.afterContext && options.afterContext > 0)
+        args.push("--after-context", String(options.afterContext));
+    if (options.glob)
+        args.push("--glob", options.glob);
+    args.push(...sensitiveFileRgGlobArgs());
+    args.push(options.query, ".");
+    try {
+        const { stdout } = await execFileAsync("rg", args, {
+            cwd: options.cwd,
+            maxBuffer: 1024 * 1024 * 10,
+        });
+        return normalizeRipgrepMatchPaths(limitLines(stdout, options.maxResults)) || "No matches.";
+    }
+    catch (error) {
+        if (isExecError(error) && error.code === 1)
+            return "No matches.";
+        if (isExecError(error) && error.code === "ENOENT") {
+            return fallbackSearchText(options);
+        }
+        throw error;
+    }
+}
+export async function searchSymbols(options) {
+    const files = await candidateSymbolFiles(options);
+    const matches = [];
+    const query = options.query
+        ? options.caseSensitive ? options.query : options.query.toLowerCase()
+        : undefined;
+    for (const file of files) {
+        if (matches.length >= options.maxResults)
+            break;
+        let content;
+        try {
+            content = await readFile(join(options.cwd, file), "utf8");
+        }
+        catch {
+            continue;
+        }
+        if (content.includes("\0"))
+            continue;
+        if (Buffer.byteLength(content, "utf8") > options.maxBytes) {
+            content = content.slice(0, options.maxBytes);
+        }
+        const lines = content.split(/\r?\n/);
+        for (let index = 0; index < lines.length; index++) {
+            for (const symbol of symbolsFromLine(lines[index])) {
+                const haystack = options.caseSensitive
+                    ? `${symbol.name}\n${symbol.signature}`
+                    : `${symbol.name}\n${symbol.signature}`.toLowerCase();
+                if (query && !haystack.includes(query))
+                    continue;
+                matches.push({
+                    path: file,
+                    line: index + 1,
+                    column: symbol.column,
+                    name: symbol.name,
+                    kind: symbol.kind,
+                    signature: symbol.signature,
+                });
+                if (matches.length >= options.maxResults)
+                    return matches;
+            }
+        }
+    }
+    return matches;
+}
+export async function findFiles(options) {
+    try {
+        const { stdout } = await execFileAsync("rg", [
+            "--files",
+            "--path-separator",
+            "/",
+            "--hidden",
+            "--glob",
+            "!{.git,node_modules,dist,build,.next,.cache}/**",
+            "--glob",
+            options.pattern,
+            ...sensitiveFileRgGlobArgs(),
+        ], {
+            cwd: options.cwd,
+            maxBuffer: 1024 * 1024 * 10,
+        });
+        return normalizePathLines(limitLines(stdout, options.maxResults)) || "No files found.";
+    }
+    catch (error) {
+        if (isExecError(error) && error.code === 1)
+            return "No files found.";
+        if (isExecError(error) && error.code === "ENOENT") {
+            const files = await fallbackFindFiles(options.cwd, options.pattern, options.maxResults);
+            return files.join("\n") || "No files found.";
+        }
+        throw error;
+    }
+}
+async function candidateSymbolFiles(options) {
+    const args = [
+        "--files",
+        "--path-separator",
+        "/",
+        "--hidden",
+        "--glob",
+        "!{.git,node_modules,dist,build,.next,.cache}/**",
+    ];
+    for (const glob of SYMBOL_FILE_GLOBS)
+        args.push("--glob", glob);
+    if (options.glob)
+        args.push("--glob", options.glob);
+    args.push(...sensitiveFileRgGlobArgs());
+    try {
+        const { stdout } = await execFileAsync("rg", args, {
+            cwd: options.cwd,
+            maxBuffer: 1024 * 1024 * 10,
+        });
+        return stdout.trimEnd().split("\n").filter(Boolean).map(toPortablePath);
+    }
+    catch (error) {
+        if (isExecError(error) && error.code === 1)
+            return [];
+        if (isExecError(error) && error.code === "ENOENT") {
+            const files = await fallbackFindFiles(options.cwd, options.glob ?? "**/*", options.maxResults * 20);
+            return files.filter((file) => SYMBOL_EXTENSIONS.has(fileExtension(file)));
+        }
+        throw error;
+    }
+}
+function symbolsFromLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("#") || trimmed.startsWith("*"))
+        return [];
+    const symbols = [];
+    for (const rule of SYMBOL_RULES) {
+        const match = rule.pattern.exec(line);
+        if (!match?.groups?.name)
+            continue;
+        if (SYMBOL_KEYWORDS.has(match.groups.name))
+            continue;
+        symbols.push({
+            name: match.groups.name,
+            kind: rule.kind,
+            signature: trimmed,
+            column: line.indexOf(match.groups.name) + 1,
+        });
+    }
+    return symbols;
+}
+async function fallbackSearchText(options) {
+    const files = await fallbackFindFiles(options.cwd, "**/*", options.maxResults * 10);
+    const needle = options.caseSensitive ? options.query : options.query.toLowerCase();
+    const matches = [];
+    for (const file of files) {
+        let content;
+        try {
+            content = await readFile(join(options.cwd, file), "utf8");
+        }
+        catch {
+            continue;
+        }
+        const lines = content.split("\n");
+        for (let index = 0; index < lines.length; index++) {
+            const haystack = options.caseSensitive ? lines[index] : lines[index].toLowerCase();
+            if (haystack.includes(needle)) {
+                for (let contextIndex = Math.max(0, index - (options.beforeContext ?? 0)); contextIndex <= Math.min(lines.length - 1, index + (options.afterContext ?? 0)); contextIndex++) {
+                    const separator = contextIndex === index ? ":" : "-";
+                    matches.push(`${file}${separator}${contextIndex + 1}${separator}${lines[contextIndex]}`);
+                }
+                if (matches.length >= options.maxResults)
+                    return matches.join("\n");
+            }
+        }
+    }
+    return matches.join("\n") || "No matches.";
+}
+function fileExtension(path) {
+    const index = path.lastIndexOf(".");
+    return index === -1 ? "" : path.slice(index);
+}
+async function fallbackFindFiles(root, pattern, maxResults) {
+    const results = [];
+    const needle = globNeedle(pattern);
+    async function walk(directory) {
+        if (results.length >= maxResults)
+            return;
+        let entries;
+        try {
+            entries = await opendir(directory);
+        }
+        catch {
+            return;
+        }
+        for await (const entry of entries) {
+            if (SKIPPED_DIRECTORIES.has(entry.name))
+                continue;
+            const path = join(directory, entry.name);
+            if (entry.isDirectory()) {
+                await walk(path);
+                continue;
+            }
+            const relativePath = relative(root, path);
+            if (isSensitiveWorkspacePath(relativePath))
+                continue;
+            if (!needle || relativePath.includes(needle)) {
+                results.push(toPortablePath(relativePath));
+                if (results.length >= maxResults)
+                    return;
+            }
+        }
+    }
+    await walk(root);
+    return results;
+}
+function globNeedle(pattern) {
+    return pattern.replace(/\*\*\/|\*|\{|\}/g, "").replace(/^\/+|\/+$/g, "");
+}
+function limitLines(text, maxLines) {
+    const lines = text.trimEnd().split("\n");
+    return lines.slice(0, maxLines).join("\n");
+}
+function normalizePathLines(text) {
+    return text
+        .split("\n")
+        .map(toPortablePath)
+        .join("\n");
+}
+function normalizeRipgrepMatchPaths(text) {
+    return text
+        .split("\n")
+        .map((line) => {
+        if (line === "--")
+            return line;
+        const match = /^(.*?)([:-]\d+[:-].*)$/.exec(line);
+        if (!match)
+            return line;
+        return `${toPortablePath(match[1])}${match[2]}`;
+    })
+        .join("\n");
+}
+function toPortablePath(path) {
+    return path.replace(/\\/g, "/");
+}
+function isExecError(error) {
+    return error instanceof Error && "code" in error;
+}
+const SKIPPED_DIRECTORIES = new Set([
+    ".git",
+    "node_modules",
+    "dist",
+    "build",
+    ".next",
+    ".cache",
+]);
+const SYMBOL_FILE_GLOBS = [
+    "*.{ts,tsx,js,jsx,mjs,cjs}",
+    "*.{py,rb,go,rs,java,kt,kts,swift}",
+    "*.{c,h,cc,cpp,cxx,hpp,cs,php}",
+];
+const SYMBOL_EXTENSIONS = new Set([
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".py",
+    ".rb",
+    ".go",
+    ".rs",
+    ".java",
+    ".kt",
+    ".kts",
+    ".swift",
+    ".c",
+    ".h",
+    ".cc",
+    ".cpp",
+    ".cxx",
+    ".hpp",
+    ".cs",
+    ".php",
+]);
+const IDENTIFIER = "[A-Za-z_$][\\w$]*";
+const SYMBOL_RULES = [
+    { kind: "function", pattern: new RegExp(`^\\s*(?:export\\s+)?(?:default\\s+)?(?:async\\s+)?function\\s+(?<name>${IDENTIFIER})\\s*\\(`) },
+    { kind: "function", pattern: new RegExp(`^\\s*(?:export\\s+)?(?:const|let|var)\\s+(?<name>${IDENTIFIER})\\s*=\\s*(?:async\\s*)?(?:\\([^)]*\\)|${IDENTIFIER})\\s*=>`) },
+    { kind: "class", pattern: new RegExp(`^\\s*(?:export\\s+)?(?:default\\s+)?class\\s+(?<name>${IDENTIFIER})\\b`) },
+    { kind: "interface", pattern: new RegExp(`^\\s*(?:export\\s+)?interface\\s+(?<name>${IDENTIFIER})\\b`) },
+    { kind: "type", pattern: new RegExp(`^\\s*(?:export\\s+)?type\\s+(?<name>${IDENTIFIER})\\b[^=]*=`) },
+    { kind: "enum", pattern: new RegExp(`^\\s*(?:export\\s+)?enum\\s+(?<name>${IDENTIFIER})\\b`) },
+    { kind: "function", pattern: new RegExp(`^\\s*(?:async\\s+)?def\\s+(?<name>${IDENTIFIER})\\s*\\(`) },
+    { kind: "class", pattern: new RegExp(`^\\s*class\\s+(?<name>${IDENTIFIER})\\b`) },
+    { kind: "function", pattern: new RegExp(`^\\s*def\\s+(?<name>[A-Za-z_]\\w*[!?=]?)\\b`) },
+    { kind: "module", pattern: new RegExp(`^\\s*module\\s+(?<name>${IDENTIFIER})\\b`) },
+    { kind: "function", pattern: new RegExp(`^\\s*func\\s+(?:\\([^)]*\\)\\s*)?(?<name>${IDENTIFIER})\\s*\\(`) },
+    { kind: "type", pattern: new RegExp(`^\\s*type\\s+(?<name>${IDENTIFIER})\\s+(?:struct|interface)\\b`) },
+    { kind: "function", pattern: new RegExp(`^\\s*(?:pub\\s+)?(?:async\\s+)?fn\\s+(?<name>${IDENTIFIER})\\s*\\(`) },
+    { kind: "class", pattern: new RegExp(`^\\s*(?:pub\\s+)?(?:struct|trait)\\s+(?<name>${IDENTIFIER})\\b`) },
+    { kind: "enum", pattern: new RegExp(`^\\s*(?:pub\\s+)?enum\\s+(?<name>${IDENTIFIER})\\b`) },
+    { kind: "class", pattern: new RegExp(`^\\s*(?:public\\s+|private\\s+|protected\\s+|internal\\s+|final\\s+|open\\s+|data\\s+|sealed\\s+|abstract\\s+)*class\\s+(?<name>${IDENTIFIER})\\b`) },
+    { kind: "interface", pattern: new RegExp(`^\\s*(?:public\\s+|private\\s+|protected\\s+|internal\\s+)*interface\\s+(?<name>${IDENTIFIER})\\b`) },
+    { kind: "enum", pattern: new RegExp(`^\\s*(?:public\\s+|private\\s+|protected\\s+|internal\\s+)*enum\\s+(?:class\\s+)?(?<name>${IDENTIFIER})\\b`) },
+    { kind: "function", pattern: new RegExp(`^\\s*(?:public\\s+|private\\s+|protected\\s+|internal\\s+|static\\s+|final\\s+|override\\s+|suspend\\s+)*fun\\s+(?<name>${IDENTIFIER})\\s*\\(`) },
+    { kind: "function", pattern: new RegExp(`^\\s*(?:public\\s+|private\\s+|protected\\s+|static\\s+|final\\s+|override\\s+|async\\s+)*[^=;{}()]+\\s+(?<name>${IDENTIFIER})\\s*\\([^;]*\\)\\s*(?:\\{|=>)`) },
+    { kind: "function", pattern: new RegExp(`^\\s*func\\s+(?<name>${IDENTIFIER})\\s*\\([^)]*\\)\\s*(?:async\\s+)?(?:throws\\s+)?(?:->\\s*[^{}]+\\s*)?\\{`) },
+    { kind: "class", pattern: new RegExp(`^\\s*(?:public\\s+|private\\s+|final\\s+|open\\s+)?(?:struct|protocol|actor)\\s+(?<name>${IDENTIFIER})\\b`) },
+];
+const SYMBOL_KEYWORDS = new Set([
+    "async",
+    "await",
+    "catch",
+    "do",
+    "else",
+    "for",
+    "if",
+    "return",
+    "switch",
+    "try",
+    "while",
+]);

package/dist/security.d.ts

@@ -0,0 +1,10 @@
+import type { LocalPortConfig } from "./permissions.js";
+export type SecuritySeverity = "info" | "warning" | "critical";
+export interface SecurityFinding {
+    id: string;
+    severity: SecuritySeverity;
+    title: string;
+    detail: string;
+    workspaceId?: string;
+}
+export declare function securityDiagnostics(config?: LocalPortConfig): SecurityFinding[];