claude-ide-bridge 1.1.0

package/dist/tools/findFiles.js

@@ -0,0 +1,119 @@
+import { execSafe, makeRelative, optionalString, requireString, resolveFilePath, success, } from "./utils.js";
+export function createFindFilesTool(workspace, probes) {
+    return {
+        schema: {
+            name: "findFiles",
+            description: "Find files by name/glob pattern in the workspace. Respects .gitignore.",
+            annotations: { readOnlyHint: true },
+            inputSchema: {
+                type: "object",
+                properties: {
+                    pattern: {
+                        type: "string",
+                        description: "Glob pattern (e.g. '*.config.ts', 'README*')",
+                    },
+                    directory: {
+                        type: "string",
+                        description: "Subdirectory to search in (relative to workspace)",
+                    },
+                },
+                required: ["pattern"],
+                additionalProperties: false,
+            },
+        },
+        handler: async (args, signal) => {
+            const pattern = requireString(args, "pattern", 200);
+            const directory = optionalString(args, "directory", 500);
+            const searchDir = directory
+                ? resolveFilePath(directory, workspace)
+                : workspace;
+            if (probes.fd) {
+                const fdArgs = ["--glob", pattern, "--max-results", "100", searchDir];
+                const result = await execSafe("fd", fdArgs, {
+                    timeout: 10000,
+                    signal,
+                });
+                const files = result.stdout
+                    .split("\n")
+                    .filter(Boolean)
+                    .map((f) => makeRelative(f, workspace));
+                const truncated = files.length === 100;
+                return success({
+                    files,
+                    count: files.length,
+                    tool: "fd",
+                    ...(truncated
+                        ? {
+                            truncated: true,
+                            note: "Result limit reached — narrow pattern or use directory",
+                        }
+                        : {}),
+                });
+            }
+            if (probes.git) {
+                const result = await execSafe("git", ["ls-files", "--cached", "--others", "--exclude-standard"], { cwd: workspace, timeout: 10000, signal });
+                const allFiles = result.stdout.split("\n").filter(Boolean);
+                // Convert glob to regex — escape metacharacters before glob substitution
+                const regexPattern = pattern
+                    .replace(/\*\*/g, "\0GLOBSTAR\0")
+                    .replace(/\*/g, "\0STAR\0")
+                    .replace(/\?/g, "\0Q\0")
+                    .replace(/[.*+^${}()|[\]\\]/g, "\\$&")
+                    .replace(/\0GLOBSTAR\0/g, ".*")
+                    .replace(/\0STAR\0/g, "[^/]*")
+                    .replace(/\0Q\0/g, "[^/]");
+                const regex = new RegExp(`(^|/)${regexPattern}$`, "i");
+                const allMatches = allFiles.filter((f) => regex.test(f));
+                const files = allMatches.slice(0, 100);
+                return success({
+                    files,
+                    count: files.length,
+                    totalMatches: allMatches.length,
+                    tool: "git-ls-files",
+                    ...(files.length < allMatches.length
+                        ? {
+                            truncated: true,
+                            note: "Result limit reached — narrow pattern or use directory",
+                        }
+                        : {}),
+                });
+            }
+            // Fallback: find
+            const findArgs = [
+                searchDir,
+                "-maxdepth",
+                "10",
+                "-name",
+                pattern,
+                "-not",
+                "-path",
+                "*/node_modules/*",
+                "-not",
+                "-path",
+                "*/.git/*",
+            ];
+            const result = await execSafe("find", findArgs, {
+                timeout: 10000,
+                signal,
+            });
+            const files = result.stdout
+                .split("\n")
+                .filter(Boolean)
+                .map((f) => makeRelative(f, workspace))
+                .slice(0, 100);
+            const truncated = files.length === 100;
+            return success({
+                files,
+                count: files.length,
+                tool: "find",
+                ...(truncated
+                    ? {
+                        truncated: true,
+                        note: "Result limit reached — narrow pattern or use directory",
+                    }
+                    : {}),
+            });
+        },
+    };
+}
+//# sourceMappingURL=findFiles.js.map

package/dist/tools/findFiles.js.map

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

package/dist/tools/fixAllLintErrors.d.ts

@@ -0,0 +1,29 @@
+import { type ExtensionClient } from "../extensionClient.js";
+import type { ProbeResults } from "../probe.js";
+export declare function createFixAllLintErrorsTool(workspace: string, probes: ProbeResults, extensionClient: ExtensionClient): {
+    schema: {
+        name: string;
+        description: string;
+        annotations: {
+            destructiveHint: boolean;
+            idempotentHint: boolean;
+        };
+        inputSchema: {
+            type: "object";
+            properties: {
+                filePath: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+            additionalProperties: false;
+        };
+    };
+    handler: (args: Record<string, unknown>, signal?: AbortSignal) => Promise<{
+        content: Array<{
+            type: string;
+            text: string;
+        }>;
+    }>;
+};

package/dist/tools/fixAllLintErrors.js

@@ -0,0 +1,114 @@
+import fs from "node:fs";
+import path from "node:path";
+import { ExtensionTimeoutError, } from "../extensionClient.js";
+import { error, execSafe, requireString, resolveFilePath, success, } from "./utils.js";
+const JS_FIXERS = [
+    { cmd: "eslint", args: (f) => ["--fix", f], probe: "eslint" },
+    { cmd: "biome", args: (f) => ["check", "--write", f], probe: "biome" },
+];
+const PY_FIXERS = [
+    { cmd: "ruff", args: (f) => ["check", "--fix", f], probe: "ruff" },
+];
+const EXT_FIXERS = {
+    ".ts": JS_FIXERS,
+    ".tsx": JS_FIXERS,
+    ".js": JS_FIXERS,
+    ".jsx": JS_FIXERS,
+    ".py": PY_FIXERS,
+};
+export function createFixAllLintErrorsTool(workspace, probes, extensionClient) {
+    return {
+        schema: {
+            name: "fixAllLintErrors",
+            description: "Auto-fix all lint errors in a file. Uses VS Code's source.fixAll action when the extension is connected, or falls back to CLI tools (eslint --fix, biome check --write, ruff check --fix). Returns a summary of changes.",
+            annotations: { destructiveHint: true, idempotentHint: true },
+            inputSchema: {
+                type: "object",
+                properties: {
+                    filePath: {
+                        type: "string",
+                        description: "Path to the file to fix (relative to workspace or absolute)",
+                    },
+                },
+                required: ["filePath"],
+                additionalProperties: false,
+            },
+        },
+        handler: async (args, signal) => {
+            const rawPath = requireString(args, "filePath");
+            const resolved = resolveFilePath(rawPath, workspace);
+            let contentBefore;
+            try {
+                contentBefore = fs.readFileSync(resolved, "utf-8");
+            }
+            catch {
+                return error({ error: `File not found: ${rawPath}` });
+            }
+            // Try extension first
+            if (extensionClient.isConnected()) {
+                try {
+                    const result = await extensionClient.fixAllLintErrors(resolved);
+                    if (result !== null) {
+                        const contentAfter = fs.readFileSync(resolved, "utf-8");
+                        return success({
+                            fixed: true,
+                            source: "extension",
+                            changes: contentBefore === contentAfter ? "none" : "modified",
+                            linesBeforeCount: contentBefore.split("\n").length,
+                            linesAfterCount: contentAfter.split("\n").length,
+                        });
+                    }
+                }
+                catch (err) {
+                    if (!(err instanceof ExtensionTimeoutError))
+                        throw err;
+                    // Timeout — fall through to CLI fallback
+                }
+            }
+            // CLI fallback
+            const ext = path.extname(resolved).toLowerCase();
+            const candidates = EXT_FIXERS[ext];
+            if (!candidates || candidates.length === 0) {
+                return error({
+                    fixed: false,
+                    source: "cli",
+                    error: `No lint fixer configured for extension "${ext}"`,
+                });
+            }
+            const fixer = candidates.find((f) => probes[f.probe]);
+            if (!fixer) {
+                const names = candidates.map((f) => f.cmd).join(", ");
+                return error({
+                    fixed: false,
+                    source: "cli",
+                    error: `No available lint fixer found. Tried: ${names}`,
+                });
+            }
+            const result = await execSafe(fixer.cmd, fixer.args(resolved), {
+                cwd: workspace,
+                timeout: 30_000,
+                signal,
+            });
+            if (result.exitCode !== 0) {
+                return error({
+                    fixed: false,
+                    source: "cli",
+                    fixerUsed: fixer.cmd,
+                    error: result.stderr,
+                });
+            }
+            const contentAfter = fs.readFileSync(resolved, "utf-8");
+            return success({
+                fixed: true,
+                source: "cli",
+                fixerUsed: fixer.cmd,
+                changes: contentBefore === contentAfter ? "none" : "modified",
+                linesBeforeCount: contentBefore.split("\n").length,
+                linesAfterCount: contentAfter.split("\n").length,
+                stdout: result.stdout,
+                stderr: result.stderr,
+            });
+        },
+    };
+}
+//# sourceMappingURL=fixAllLintErrors.js.map

package/dist/tools/fixAllLintErrors.js.map

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

package/dist/tools/flowGuardian.d.ts

@@ -0,0 +1,61 @@
+export declare function createCheckScopeTool(workspace: string): {
+    schema: {
+        name: string;
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+        };
+        inputSchema: {
+            type: "object";
+            required: string[];
+            properties: {
+                filePath: {
+                    type: string;
+                    description: string;
+                };
+                operation: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+            };
+            additionalProperties: false;
+        };
+    };
+    handler: (args: Record<string, unknown>) => Promise<{
+        content: Array<{
+            type: string;
+            text: string;
+        }>;
+    }>;
+};
+export declare function createExpandScopeTool(workspace: string): {
+    schema: {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: "object";
+            required: string[];
+            properties: {
+                entries: {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                    description: string;
+                };
+                fileName: {
+                    type: string;
+                    description: string;
+                };
+            };
+            additionalProperties: false;
+        };
+    };
+    handler: (args: Record<string, unknown>) => Promise<{
+        content: Array<{
+            type: string;
+            text: string;
+        }>;
+    }>;
+};

package/dist/tools/flowGuardian.js

@@ -0,0 +1,311 @@
+import fsp from "node:fs/promises";
+import path from "node:path";
+import { error, optionalString, requireString, resolveFilePath, success, } from "./utils.js";
+function parseScopeSection(lines) {
+    const entries = [];
+    for (const line of lines) {
+        const match = line.match(/^- (.+)/);
+        if (!match)
+            continue;
+        let pattern = match[1]?.trim();
+        if (!pattern)
+            continue;
+        const isNegation = pattern.startsWith("!");
+        if (isNegation)
+            pattern = pattern.slice(1);
+        entries.push({
+            pattern,
+            isDirectory: pattern.endsWith("/"),
+            isGlob: pattern.includes("*"),
+            isNegation,
+        });
+    }
+    return entries;
+}
+function matchesScopeEntry(relativePath, entry) {
+    if (entry.isGlob)
+        return matchesGlob(relativePath, entry.pattern);
+    if (entry.isDirectory) {
+        return (relativePath.startsWith(entry.pattern) ||
+            relativePath.startsWith(entry.pattern.slice(0, -1)));
+    }
+    return relativePath === entry.pattern;
+}
+function extractImplicitPaths(content) {
+    const paths = new Set();
+    // Backtick-wrapped paths
+    const backtickRegex = /`([\w./-]+(?:\.\w+)?)`/g;
+    let m;
+    while ((m = backtickRegex.exec(content)) !== null) {
+        const p = m[1];
+        if (p.includes("/") || p.includes("."))
+            paths.add(p);
+    }
+    // Bare path-like mentions (word/word.ext or word/word/)
+    const bareRegex = /(?:^|\s)((?:[\w-]+\/)+[\w.-]+)/gm;
+    while ((m = bareRegex.exec(content)) !== null) {
+        paths.add(m[1]);
+    }
+    return [...paths];
+}
+function matchesGlob(filePath, pattern) {
+    // Guard against ReDoS: reject overly complex patterns
+    if (pattern.length > 200)
+        return false;
+    if ((pattern.match(/\*/g) || []).length > 10)
+        return false;
+    // Collapse consecutive * (same fix as minimatch 10.2.1 for CVE-2026-27904)
+    const collapsed = pattern.replace(/\*{3,}/g, "**");
+    // Simple glob matching: ** matches any path segments, * matches within segment
+    const regexStr = collapsed
+        .replace(/[.+^${}()|[\]\\?]/g, "\\$&")
+        .replace(/\*\*/g, "§§")
+        .replace(/\*/g, "[^/]*")
+        .replace(/§§/g, ".*");
+    return new RegExp(`^${regexStr}$`).test(filePath);
+}
+export function createCheckScopeTool(workspace) {
+    return {
+        schema: {
+            name: "checkScope",
+            description: "Check whether a file path and operation are in-scope for the active plan (.claude-plan.md). Advisory only — returns scope status and suggested action.",
+            annotations: { readOnlyHint: true },
+            inputSchema: {
+                type: "object",
+                required: ["filePath"],
+                properties: {
+                    filePath: {
+                        type: "string",
+                        description: "File path to check (absolute or relative to workspace)",
+                    },
+                    operation: {
+                        type: "string",
+                        enum: ["read", "write", "delete", "create"],
+                        description: "Type of operation being considered. Default: 'write'",
+                    },
+                },
+                additionalProperties: false,
+            },
+        },
+        handler: async (args) => {
+            const rawPath = requireString(args, "filePath");
+            const operation = optionalString(args, "operation") ?? "write";
+            const resolved = resolveFilePath(rawPath, workspace);
+            const relativePath = path.relative(workspace, resolved);
+            // Try to read the plan file
+            const planPath = path.join(workspace, ".claude-plan.md");
+            if (!(await fsp.access(planPath).then(() => true, () => false))) {
+                return success({
+                    planFound: false,
+                    inScope: true,
+                    reason: "No active plan found — all operations permitted",
+                    suggestedAction: "proceed",
+                    scopeSection: false,
+                });
+            }
+            const content = await fsp.readFile(planPath, "utf-8");
+            // Read operations are always in scope
+            if (operation === "read") {
+                return success({
+                    planFound: true,
+                    inScope: true,
+                    reason: "Read operations are always in scope",
+                    suggestedAction: "proceed",
+                    scopeSection: false,
+                });
+            }
+            // Parse ## Scope section
+            const lines = content.split("\n");
+            let inScopeSection = false;
+            const scopeLines = [];
+            for (const line of lines) {
+                if (line.match(/^## Scope/i)) {
+                    inScopeSection = true;
+                    continue;
+                }
+                if (inScopeSection && line.match(/^## /))
+                    break;
+                if (inScopeSection)
+                    scopeLines.push(line);
+            }
+            const hasExplicitScope = scopeLines.length > 0;
+            const scopeEntries = parseScopeSection(scopeLines);
+            const implicitPaths = extractImplicitPaths(content);
+            // Check explicit scope entries
+            if (hasExplicitScope) {
+                // Check negations first — if a negation matches, block immediately
+                for (const entry of scopeEntries) {
+                    if (entry.isNegation && matchesScopeEntry(relativePath, entry)) {
+                        return success({
+                            planFound: true,
+                            inScope: false,
+                            reason: `Excluded by negation pattern: !${entry.pattern}`,
+                            suggestedAction: "block",
+                            scopeSection: true,
+                        });
+                    }
+                }
+                // Check positive scope entries
+                for (const entry of scopeEntries) {
+                    if (entry.isNegation)
+                        continue;
+                    if (matchesScopeEntry(relativePath, entry)) {
+                        const reason = entry.isGlob
+                            ? `Matches scope glob pattern: ${entry.pattern}`
+                            : entry.isDirectory
+                                ? `Within scoped directory: ${entry.pattern}`
+                                : `Exact match in scope: ${entry.pattern}`;
+                        return success({
+                            planFound: true,
+                            inScope: true,
+                            reason,
+                            suggestedAction: "proceed",
+                            scopeSection: true,
+                        });
+                    }
+                }
+                // Check if it's in a mentioned directory but not explicitly scoped
+                for (const p of implicitPaths) {
+                    if (relativePath === p || relativePath.startsWith(`${p}/`)) {
+                        return success({
+                            planFound: true,
+                            inScope: true,
+                            reason: `Mentioned in plan body but not in explicit Scope section: ${p}`,
+                            suggestedAction: "warn",
+                            scopeSection: true,
+                        });
+                    }
+                }
+                const positiveEntries = scopeEntries.filter((e) => !e.isNegation);
+                return success({
+                    planFound: true,
+                    inScope: false,
+                    reason: `Not matched by any Scope entry. Scoped to: ${positiveEntries.map((e) => e.pattern).join(", ")}`,
+                    suggestedAction: "block",
+                    scopeSection: true,
+                });
+            }
+            // No explicit scope — use implicit mentions
+            for (const p of implicitPaths) {
+                if (relativePath === p || relativePath.startsWith(`${p}/`)) {
+                    return success({
+                        planFound: true,
+                        inScope: true,
+                        reason: `Mentioned in plan: ${p}`,
+                        suggestedAction: "proceed",
+                        scopeSection: false,
+                    });
+                }
+            }
+            // Check if any implicit path shares a directory prefix
+            const relativeDir = path.dirname(relativePath);
+            for (const p of implicitPaths) {
+                const pDir = path.dirname(p);
+                if (relativeDir === pDir || relativeDir.startsWith(`${pDir}/`)) {
+                    return success({
+                        planFound: true,
+                        inScope: true,
+                        reason: `In same directory as plan-mentioned file: ${p}`,
+                        suggestedAction: "proceed",
+                        scopeSection: false,
+                    });
+                }
+            }
+            return success({
+                planFound: true,
+                inScope: false,
+                reason: "File not mentioned in plan",
+                suggestedAction: "warn",
+                scopeSection: false,
+            });
+        },
+    };
+}
+export function createExpandScopeTool(workspace) {
+    return {
+        schema: {
+            name: "expandScope",
+            description: "Add entries to the ## Scope section of the active plan (.claude-plan.md). Creates the section if it doesn't exist.",
+            inputSchema: {
+                type: "object",
+                required: ["entries"],
+                properties: {
+                    entries: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Scope entries to add (e.g., 'src/utils/', '!dist/', '**/*.test.ts')",
+                    },
+                    fileName: {
+                        type: "string",
+                        description: "Plan filename (default: .claude-plan.md)",
+                    },
+                },
+                additionalProperties: false,
+            },
+        },
+        handler: async (args) => {
+            const rawEntries = args.entries;
+            if (!Array.isArray(rawEntries) || rawEntries.length === 0) {
+                return error("entries must be a non-empty array of strings");
+            }
+            if (rawEntries.length > 100) {
+                return error("Maximum 100 scope entries allowed at once");
+            }
+            const entries = rawEntries
+                .filter((e) => typeof e === "string")
+                .map((e) => e.replace(/[\n\r]/g, "").trim())
+                .filter((e) => e.length > 0 && e.length <= 200);
+            if (entries.length === 0) {
+                return error("No valid entries provided");
+            }
+            const fileName = optionalString(args, "fileName") ?? ".claude-plan.md";
+            const planPath = resolveFilePath(fileName, workspace);
+            if (!(await fsp.access(planPath).then(() => true, () => false))) {
+                return error(`Plan file "${fileName}" not found. Use createPlan to create one.`);
+            }
+            const content = await fsp.readFile(planPath, "utf-8");
+            const lines = content.split("\n");
+            // Find ## Scope section
+            let scopeStart = -1;
+            let scopeEnd = lines.length;
+            for (let i = 0; i < lines.length; i++) {
+                if (lines[i]?.match(/^## Scope/i)) {
+                    scopeStart = i;
+                    for (let j = i + 1; j < lines.length; j++) {
+                        if (lines[j]?.match(/^## /)) {
+                            scopeEnd = j;
+                            break;
+                        }
+                    }
+                    break;
+                }
+            }
+            const newLines = entries.map((e) => `- ${e.trim()}`);
+            if (scopeStart === -1) {
+                // No Scope section — insert after frontmatter
+                let insertAt = 0;
+                if (lines[0]?.trim() === "---") {
+                    for (let i = 1; i < lines.length; i++) {
+                        if (lines[i]?.trim() === "---") {
+                            insertAt = i + 1;
+                            break;
+                        }
+                    }
+                }
+                const section = ["", "## Scope", "", ...newLines, ""];
+                lines.splice(insertAt, 0, ...section);
+            }
+            else {
+                // Insert before the next section (or end)
+                lines.splice(scopeEnd, 0, ...newLines);
+            }
+            await fsp.writeFile(planPath, lines.join("\n"), "utf-8");
+            return success({
+                expanded: true,
+                entriesAdded: entries.length,
+                entries,
+            });
+        },
+    };
+}
+//# sourceMappingURL=flowGuardian.js.map