@freesyntax/notch-cli 0.5.16 → 0.5.19

package/dist/chunk-GBZGR6ID.js

@@ -0,0 +1,174 @@
+// src/tools/github.ts
+import { z } from "zod";
+var GITHUB_API = "https://api.github.com";
+function getToken() {
+  return process.env.GITHUB_TOKEN || process.env.GH_TOKEN || null;
+}
+async function ghFetch(path, opts = {}) {
+  const token = getToken();
+  const headers = {
+    "Accept": "application/vnd.github+json",
+    "X-GitHub-Api-Version": "2022-11-28",
+    ...opts.headers ?? {}
+  };
+  if (token) headers["Authorization"] = `Bearer ${token}`;
+  return fetch(`${GITHUB_API}${path}`, { ...opts, headers });
+}
+var parameters = z.object({
+  action: z.enum([
+    "create_pr",
+    "list_prs",
+    "list_issues",
+    "repo_info",
+    "create_issue",
+    "pr_status"
+  ]).describe("The GitHub operation to perform"),
+  owner: z.string().describe("Repository owner (user or org)"),
+  repo: z.string().describe("Repository name"),
+  // PR fields
+  title: z.string().optional().describe("PR or issue title"),
+  body: z.string().optional().describe("PR or issue body/description"),
+  head: z.string().optional().describe("PR source branch"),
+  base: z.string().optional().describe("PR target branch (default: main)"),
+  // Issue fields
+  labels: z.array(z.string()).optional().describe("Labels for issue"),
+  // Filter
+  state: z.enum(["open", "closed", "all"]).optional().describe("Filter by state"),
+  pr_number: z.number().optional().describe("PR number for status check")
+});
+async function execute(args, _ctx) {
+  const token = getToken();
+  if (!token) {
+    return {
+      content: "No GitHub token found. Set GITHUB_TOKEN or GH_TOKEN environment variable.\nYou can create a token at https://github.com/settings/tokens",
+      isError: true
+    };
+  }
+  try {
+    switch (args.action) {
+      case "repo_info": {
+        const res = await ghFetch(`/repos/${args.owner}/${args.repo}`);
+        if (!res.ok) return { content: `GitHub API error: ${res.status} ${await res.text()}`, isError: true };
+        const repo = await res.json();
+        return {
+          content: [
+            `Repository: ${repo.full_name}`,
+            `Description: ${repo.description || "None"}`,
+            `Stars: ${repo.stargazers_count} | Forks: ${repo.forks_count} | Open issues: ${repo.open_issues_count}`,
+            `Default branch: ${repo.default_branch}`,
+            `Language: ${repo.language || "Unknown"}`,
+            `Private: ${repo.private}`,
+            `URL: ${repo.html_url}`
+          ].join("\n")
+        };
+      }
+      case "list_prs": {
+        const state = args.state ?? "open";
+        const res = await ghFetch(`/repos/${args.owner}/${args.repo}/pulls?state=${state}&per_page=15`);
+        if (!res.ok) return { content: `GitHub API error: ${res.status}`, isError: true };
+        const prs = await res.json();
+        if (prs.length === 0) return { content: `No ${state} pull requests.` };
+        const lines = prs.map(
+          (pr) => `#${pr.number} [${pr.state}] ${pr.title} (${pr.head.ref} \u2192 ${pr.base.ref}) by @${pr.user.login}`
+        );
+        return { content: lines.join("\n") };
+      }
+      case "list_issues": {
+        const state = args.state ?? "open";
+        const res = await ghFetch(`/repos/${args.owner}/${args.repo}/issues?state=${state}&per_page=15`);
+        if (!res.ok) return { content: `GitHub API error: ${res.status}`, isError: true };
+        const issues = await res.json();
+        const realIssues = issues.filter((i) => !i.pull_request);
+        if (realIssues.length === 0) return { content: `No ${state} issues.` };
+        const lines = realIssues.map((i) => {
+          const labels = i.labels.map((l) => l.name).join(", ");
+          return `#${i.number} [${i.state}] ${i.title}${labels ? ` [${labels}]` : ""} by @${i.user.login}`;
+        });
+        return { content: lines.join("\n") };
+      }
+      case "create_pr": {
+        if (!args.title || !args.head) {
+          return { content: "title and head branch are required for create_pr", isError: true };
+        }
+        const res = await ghFetch(`/repos/${args.owner}/${args.repo}/pulls`, {
+          method: "POST",
+          body: JSON.stringify({
+            title: args.title,
+            body: args.body ?? "",
+            head: args.head,
+            base: args.base ?? "main"
+          })
+        });
+        if (!res.ok) {
+          const err = await res.json();
+          return { content: `Failed to create PR: ${err.message || res.status}`, isError: true };
+        }
+        const pr = await res.json();
+        return { content: `PR #${pr.number} created: ${pr.html_url}` };
+      }
+      case "create_issue": {
+        if (!args.title) {
+          return { content: "title is required for create_issue", isError: true };
+        }
+        const res = await ghFetch(`/repos/${args.owner}/${args.repo}/issues`, {
+          method: "POST",
+          body: JSON.stringify({
+            title: args.title,
+            body: args.body ?? "",
+            labels: args.labels ?? []
+          })
+        });
+        if (!res.ok) {
+          const err = await res.json();
+          return { content: `Failed to create issue: ${err.message || res.status}`, isError: true };
+        }
+        const issue = await res.json();
+        return { content: `Issue #${issue.number} created: ${issue.html_url}` };
+      }
+      case "pr_status": {
+        if (!args.pr_number) {
+          return { content: "pr_number is required for pr_status", isError: true };
+        }
+        const res = await ghFetch(`/repos/${args.owner}/${args.repo}/pulls/${args.pr_number}`);
+        if (!res.ok) return { content: `GitHub API error: ${res.status}`, isError: true };
+        const pr = await res.json();
+        const checksRes = await ghFetch(`/repos/${args.owner}/${args.repo}/commits/${pr.head.sha}/check-runs`);
+        let checksInfo = "";
+        if (checksRes.ok) {
+          const checks = await checksRes.json();
+          if (checks.check_runs?.length) {
+            checksInfo = "\nChecks:\n" + checks.check_runs.map(
+              (c) => `  ${c.status === "completed" ? c.conclusion === "success" ? "\u2713" : "\u2717" : "\u25CC"} ${c.name}: ${c.conclusion ?? c.status}`
+            ).join("\n");
+          }
+        }
+        return {
+          content: [
+            `PR #${pr.number}: ${pr.title}`,
+            `State: ${pr.state} | Mergeable: ${pr.mergeable ?? "checking..."}`,
+            `${pr.head.ref} \u2192 ${pr.base.ref}`,
+            `Author: @${pr.user.login}`,
+            `+${pr.additions} -${pr.deletions} (${pr.changed_files} files)`,
+            `Reviews: ${pr.requested_reviewers?.length ?? 0} requested`,
+            checksInfo,
+            `URL: ${pr.html_url}`
+          ].join("\n")
+        };
+      }
+      default:
+        return { content: `Unknown action: ${args.action}`, isError: true };
+    }
+  } catch (err) {
+    return { content: `GitHub error: ${err.message}`, isError: true };
+  }
+}
+var githubTool = {
+  name: "github",
+  description: "GitHub operations \u2014 create PRs, list issues, check PR status, view repo info. Requires GITHUB_TOKEN env var.",
+  parameters,
+  execute
+};
+
+export {
+  githubTool
+};

package/dist/chunk-KZAS754V.js

@@ -0,0 +1,118 @@
+// src/tools/notebook.ts
+import fs from "fs/promises";
+import path from "path";
+import { z } from "zod";
+var parameters = z.object({
+  action: z.enum(["read", "edit", "add", "remove"]).describe("Action: read (view cells), edit (modify cell source), add (insert new cell), remove (delete cell)"),
+  path: z.string().describe("Path to the .ipynb notebook file"),
+  cell_index: z.number().optional().describe("Cell index (0-based) \u2014 for edit/remove actions"),
+  cell_type: z.enum(["code", "markdown", "raw"]).optional().describe("Cell type \u2014 for add action"),
+  content: z.string().optional().describe("New cell content \u2014 for edit/add actions"),
+  insert_after: z.number().optional().describe("Insert after this cell index \u2014 for add action (-1 for beginning)")
+});
+function formatNotebook(nb, filePath) {
+  const parts = [
+    `# ${path.basename(filePath)}`,
+    `# ${nb.cells.length} cells | nbformat ${nb.nbformat}.${nb.nbformat_minor}`,
+    ""
+  ];
+  for (let i = 0; i < nb.cells.length; i++) {
+    const cell = nb.cells[i];
+    const source = cell.source.join("");
+    const header = cell.cell_type === "code" ? `[${i}] Code (exec: ${cell.execution_count ?? "-"})` : `[${i}] ${cell.cell_type.charAt(0).toUpperCase() + cell.cell_type.slice(1)}`;
+    parts.push(`--- ${header} ---`);
+    parts.push(source);
+    if (cell.cell_type === "code" && cell.outputs && cell.outputs.length > 0) {
+      parts.push("  Output:");
+      for (const output of cell.outputs) {
+        if (output.text) {
+          parts.push("  " + output.text.join("").slice(0, 500));
+        } else if (output.data?.["text/plain"]) {
+          parts.push("  " + output.data["text/plain"].join("").slice(0, 500));
+        } else if (output.ename) {
+          parts.push(`  Error: ${output.ename}: ${output.evalue}`);
+        }
+      }
+    }
+    parts.push("");
+  }
+  return parts.join("\n");
+}
+var notebookTool = {
+  name: "notebook",
+  description: "Read and edit Jupyter .ipynb notebook files. Actions: read (view all cells with outputs), edit (modify a cell), add (insert a new cell), remove (delete a cell).",
+  parameters,
+  async execute(params, ctx) {
+    const filePath = path.isAbsolute(params.path) ? params.path : path.resolve(ctx.cwd, params.path);
+    try {
+      switch (params.action) {
+        case "read": {
+          const raw = await fs.readFile(filePath, "utf-8");
+          const nb = JSON.parse(raw);
+          return { content: formatNotebook(nb, filePath) };
+        }
+        case "edit": {
+          if (params.cell_index === void 0) {
+            return { content: "cell_index is required for edit action.", isError: true };
+          }
+          if (params.content === void 0) {
+            return { content: "content is required for edit action.", isError: true };
+          }
+          const raw = await fs.readFile(filePath, "utf-8");
+          const nb = JSON.parse(raw);
+          if (params.cell_index < 0 || params.cell_index >= nb.cells.length) {
+            return { content: `Cell index ${params.cell_index} out of range (0-${nb.cells.length - 1}).`, isError: true };
+          }
+          const lines = params.content.split("\n").map(
+            (l, i, arr) => i < arr.length - 1 ? l + "\n" : l
+          );
+          nb.cells[params.cell_index].source = lines;
+          await fs.writeFile(filePath, JSON.stringify(nb, null, 1) + "\n");
+          return { content: `Cell [${params.cell_index}] updated in ${path.basename(filePath)}.` };
+        }
+        case "add": {
+          if (params.content === void 0) {
+            return { content: "content is required for add action.", isError: true };
+          }
+          const raw = await fs.readFile(filePath, "utf-8");
+          const nb = JSON.parse(raw);
+          const cellType = params.cell_type ?? "code";
+          const lines = params.content.split("\n").map(
+            (l, i, arr) => i < arr.length - 1 ? l + "\n" : l
+          );
+          const newCell = {
+            cell_type: cellType,
+            source: lines,
+            metadata: {},
+            ...cellType === "code" ? { outputs: [], execution_count: null } : {}
+          };
+          const insertIdx = params.insert_after !== void 0 ? params.insert_after + 1 : nb.cells.length;
+          nb.cells.splice(insertIdx, 0, newCell);
+          await fs.writeFile(filePath, JSON.stringify(nb, null, 1) + "\n");
+          return { content: `Added ${cellType} cell at index [${insertIdx}] in ${path.basename(filePath)}.` };
+        }
+        case "remove": {
+          if (params.cell_index === void 0) {
+            return { content: "cell_index is required for remove action.", isError: true };
+          }
+          const raw = await fs.readFile(filePath, "utf-8");
+          const nb = JSON.parse(raw);
+          if (params.cell_index < 0 || params.cell_index >= nb.cells.length) {
+            return { content: `Cell index ${params.cell_index} out of range (0-${nb.cells.length - 1}).`, isError: true };
+          }
+          const removed = nb.cells.splice(params.cell_index, 1)[0];
+          await fs.writeFile(filePath, JSON.stringify(nb, null, 1) + "\n");
+          return { content: `Removed ${removed.cell_type} cell [${params.cell_index}] from ${path.basename(filePath)}. ${nb.cells.length} cells remaining.` };
+        }
+        default:
+          return { content: `Unknown action: ${params.action}`, isError: true };
+      }
+    } catch (err) {
+      return { content: `Notebook error: ${err.message}`, isError: true };
+    }
+  }
+};
+
+export {
+  notebookTool
+};

package/dist/chunk-O3WZW7GS.js

@@ -0,0 +1,35 @@
+// src/tools/write.ts
+import fs from "fs/promises";
+import path from "path";
+import { z } from "zod";
+var parameters = z.object({
+  path: z.string().describe("Relative or absolute path to write"),
+  content: z.string().describe("Complete file content to write")
+});
+var writeTool = {
+  name: "write",
+  description: "Write a file (create or overwrite). Creates parent directories if needed. Always provide the COMPLETE file content.",
+  parameters,
+  async execute(params, ctx) {
+    const filePath = path.isAbsolute(params.path) ? params.path : path.resolve(ctx.cwd, params.path);
+    try {
+      await fs.mkdir(path.dirname(filePath), { recursive: true });
+      let existed = false;
+      try {
+        await fs.access(filePath);
+        existed = true;
+      } catch {
+      }
+      await fs.writeFile(filePath, params.content, "utf-8");
+      const lines = params.content.split("\n").length;
+      const action = existed ? "Updated" : "Created";
+      return { content: `${action} ${filePath} (${lines} lines)` };
+    } catch (err) {
+      return { content: `Error writing ${filePath}: ${err.message}`, isError: true };
+    }
+  }
+};
+
+export {
+  writeTool
+};

package/dist/chunk-TH6GKC7E.js

@@ -0,0 +1,315 @@
+// src/tools/lsp.ts
+import { execFileSync } from "child_process";
+import fs from "fs/promises";
+import path from "path";
+import { z } from "zod";
+var parameters = z.object({
+  action: z.enum(["definition", "references", "diagnostics", "hover"]).describe("LSP action: definition (go-to-def), references (find usages), diagnostics (type errors), hover (type info)"),
+  file: z.string().describe("File path (relative or absolute)"),
+  line: z.number().optional().describe("Line number (1-based) \u2014 required for definition, references, hover"),
+  character: z.number().optional().describe("Column number (0-based) \u2014 required for definition, references, hover"),
+  symbol: z.string().optional().describe("Symbol name to search for (alternative to line/character)")
+});
+function detectLanguage(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  switch (ext) {
+    case ".ts":
+    case ".tsx":
+    case ".js":
+    case ".jsx":
+    case ".mjs":
+    case ".cjs":
+      return { lang: "typescript", server: "typescript-language-server", tsconfig: true };
+    case ".py":
+      return { lang: "python", server: "pyright", tsconfig: false };
+    case ".go":
+      return { lang: "go", server: "gopls", tsconfig: false };
+    case ".rs":
+      return { lang: "rust", server: "rust-analyzer", tsconfig: false };
+    default:
+      return { lang: "unknown", server: null, tsconfig: false };
+  }
+}
+function isAvailable(cmd) {
+  try {
+    const which = process.platform === "win32" ? "where" : "which";
+    execFileSync(which, [cmd], { stdio: "pipe", timeout: 3e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function tsDiagnostics(filePath, cwd) {
+  try {
+    const result = execFileSync("npx", ["tsc", "--noEmit", "--pretty", "false", filePath], {
+      cwd,
+      encoding: "utf-8",
+      timeout: 3e4
+    });
+    return result.trim() || "No type errors found.";
+  } catch (err) {
+    const output = err.stdout || err.stderr || "";
+    if (output.includes("error TS")) {
+      const lines = output.split("\n").filter((l) => l.includes("error TS"));
+      return lines.slice(0, 20).join("\n") || "No type errors found.";
+    }
+    try {
+      const result = execFileSync("npx", ["tsc", "--noEmit", "--pretty", "false"], {
+        cwd,
+        encoding: "utf-8",
+        timeout: 3e4
+      });
+      const allLines = result.trim().split("\n").slice(0, 30).join("\n");
+      return allLines || "No type errors found.";
+    } catch (err2) {
+      const out = err2.stdout || err2.stderr || "";
+      const errLines = out.split("\n").filter((l) => l.includes("error TS"));
+      return errLines.slice(0, 20).join("\n") || "Could not run type checker.";
+    }
+  }
+}
+async function findDefinition(symbol, cwd) {
+  if (!/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(symbol)) {
+    return `Invalid symbol name: "${symbol}"`;
+  }
+  const patterns = [
+    `(function|const|let|var|class|interface|type|enum)\\s+${symbol}\\b`,
+    `export\\s+(default\\s+)?(function|const|let|var|class|interface|type|enum)\\s+${symbol}\\b`,
+    `def\\s+${symbol}\\s*\\(`,
+    // Python
+    `func\\s+${symbol}\\s*\\(`,
+    // Go
+    `fn\\s+${symbol}\\s*[<(]`
+    // Rust
+  ];
+  const combinedPattern = patterns.join("|");
+  try {
+    const result = execFileSync("rg", [
+      "--no-heading",
+      "--line-number",
+      "-e",
+      combinedPattern,
+      "--type-add",
+      "code:*.{ts,tsx,js,jsx,py,go,rs}",
+      "--type",
+      "code",
+      "-m",
+      "10"
+    ], { cwd, encoding: "utf-8", timeout: 1e4, maxBuffer: 1024 * 1024 });
+    return result.trim() || `No definition found for "${symbol}"`;
+  } catch {
+    try {
+      const result = execFileSync("grep", [
+        "-rn",
+        "-E",
+        combinedPattern,
+        "--include=*.ts",
+        "--include=*.tsx",
+        "--include=*.js",
+        "--include=*.py",
+        "--include=*.go",
+        "--include=*.rs",
+        "."
+      ], { cwd, encoding: "utf-8", timeout: 1e4, maxBuffer: 1024 * 1024 });
+      const lines = result.trim().split("\n").slice(0, 10).join("\n");
+      return lines || `No definition found for "${symbol}"`;
+    } catch {
+      return `No definition found for "${symbol}"`;
+    }
+  }
+}
+async function findReferences(symbol, cwd) {
+  if (!/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(symbol)) {
+    return `Invalid symbol name: "${symbol}"`;
+  }
+  try {
+    const result = execFileSync("rg", [
+      "--no-heading",
+      "--line-number",
+      "-w",
+      symbol,
+      "--type-add",
+      "code:*.{ts,tsx,js,jsx,py,go,rs}",
+      "--type",
+      "code",
+      "-m",
+      "30"
+    ], { cwd, encoding: "utf-8", timeout: 1e4, maxBuffer: 1024 * 1024 });
+    const lines = result.trim().split("\n");
+    return `Found ${lines.length} reference(s) for "${symbol}":
+
+${lines.join("\n")}`;
+  } catch {
+    try {
+      const result = execFileSync("grep", [
+        "-rn",
+        "-w",
+        symbol,
+        "--include=*.ts",
+        "--include=*.tsx",
+        "--include=*.js",
+        "--include=*.py",
+        "--include=*.go",
+        "--include=*.rs",
+        "."
+      ], { cwd, encoding: "utf-8", timeout: 1e4, maxBuffer: 1024 * 1024 });
+      const lines = result.trim().split("\n").slice(0, 30);
+      return `Found ${lines.length} reference(s) for "${symbol}":
+
+${lines.join("\n")}`;
+    } catch {
+      return `No references found for "${symbol}"`;
+    }
+  }
+}
+async function getHoverInfo(symbol, filePath, line, cwd) {
+  try {
+    const absPath = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+    const content = await fs.readFile(absPath, "utf-8");
+    const lines = content.split("\n");
+    const startLine = Math.max(0, line - 3);
+    const endLine = Math.min(lines.length, line + 2);
+    const context = lines.slice(startLine, endLine).map((l, i) => `${startLine + i + 1}: ${l}`).join("\n");
+    const def = await findDefinition(symbol, cwd);
+    return `## Context at ${filePath}:${line}
+\`\`\`
+${context}
+\`\`\`
+
+## Definition
+${def}`;
+  } catch (err) {
+    return `Could not get hover info: ${err.message}`;
+  }
+}
+async function getDiagnostics(filePath, cwd) {
+  const absPath = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+  const { lang } = detectLanguage(absPath);
+  switch (lang) {
+    case "typescript":
+      return tsDiagnostics(absPath, cwd);
+    case "python": {
+      if (isAvailable("pyright")) {
+        try {
+          const result = execFileSync("pyright", [absPath], {
+            cwd,
+            encoding: "utf-8",
+            timeout: 3e4
+          });
+          return result.trim() || "No errors found.";
+        } catch (err) {
+          return err.stdout || err.stderr || "Pyright check failed.";
+        }
+      }
+      try {
+        execFileSync("python", ["-m", "py_compile", absPath], {
+          cwd,
+          encoding: "utf-8",
+          timeout: 1e4
+        });
+        return "No syntax errors found.";
+      } catch (err) {
+        return err.stderr || err.stdout || "Syntax check failed.";
+      }
+    }
+    case "go": {
+      try {
+        const result = execFileSync("go", ["vet", absPath], {
+          cwd,
+          encoding: "utf-8",
+          timeout: 15e3
+        });
+        return result.trim() || "No issues found.";
+      } catch (err) {
+        return err.stderr || err.stdout || "Go vet failed.";
+      }
+    }
+    case "rust": {
+      try {
+        const result = execFileSync("cargo", ["check", "--message-format", "short"], {
+          cwd,
+          encoding: "utf-8",
+          timeout: 6e4
+        });
+        const lines = result.trim().split("\n").slice(0, 30).join("\n");
+        return lines || "No issues found.";
+      } catch (err) {
+        return err.stderr || err.stdout || "Cargo check failed.";
+      }
+    }
+    default:
+      return `No language server available for ${lang} files. Use grep to search for symbols.`;
+  }
+}
+var lspTool = {
+  name: "lsp",
+  description: "Code intelligence: find definitions, references, type errors, and hover info. Uses TypeScript compiler, pyright, gopls, or grep-based heuristics. Actions: definition (go-to-def), references (find usages), diagnostics (type errors), hover (type info). Provide either line/character position or a symbol name.",
+  parameters,
+  async execute(params, ctx) {
+    const filePath = params.file;
+    const absPath = path.isAbsolute(filePath) ? filePath : path.resolve(ctx.cwd, filePath);
+    try {
+      switch (params.action) {
+        case "definition": {
+          const symbol = params.symbol || await extractSymbol(absPath, params.line, params.character);
+          if (!symbol) {
+            return { content: "Provide a symbol name or line/character position.", isError: true };
+          }
+          const result = await findDefinition(symbol, ctx.cwd);
+          return { content: result };
+        }
+        case "references": {
+          const symbol = params.symbol || await extractSymbol(absPath, params.line, params.character);
+          if (!symbol) {
+            return { content: "Provide a symbol name or line/character position.", isError: true };
+          }
+          const result = await findReferences(symbol, ctx.cwd);
+          return { content: result };
+        }
+        case "diagnostics": {
+          const result = await getDiagnostics(filePath, ctx.cwd);
+          return { content: result };
+        }
+        case "hover": {
+          const symbol = params.symbol || await extractSymbol(absPath, params.line, params.character);
+          if (!symbol) {
+            return { content: "Provide a symbol name or line/character position.", isError: true };
+          }
+          const result = await getHoverInfo(symbol, filePath, params.line ?? 1, ctx.cwd);
+          return { content: result };
+        }
+        default:
+          return { content: `Unknown action: ${params.action}`, isError: true };
+      }
+    } catch (err) {
+      return { content: `LSP error: ${err.message}`, isError: true };
+    }
+  }
+};
+async function extractSymbol(filePath, line, character) {
+  if (!line) return null;
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    const lines = content.split("\n");
+    const lineText = lines[line - 1];
+    if (!lineText) return null;
+    const col = character ?? 0;
+    const wordRegex = /[a-zA-Z_$][a-zA-Z0-9_$]*/g;
+    let match;
+    while ((match = wordRegex.exec(lineText)) !== null) {
+      const start = match.index;
+      const end = start + match[0].length;
+      if (col >= start && col <= end) {
+        return match[0];
+      }
+    }
+    const firstMatch = lineText.match(/[a-zA-Z_$][a-zA-Z0-9_$]*/);
+    return firstMatch?.[0] ?? null;
+  } catch {
+    return null;
+  }
+}
+
+export {
+  lspTool
+};