fchek 1.0.0

package/lib/goto.js

@@ -0,0 +1,544 @@
+'use strict';
+
+const { spawnSync, execSync } = require('child_process');
+const path   = require('path');
+const fs     = require('fs');
+const os     = require('os');
+const { output, ok, fail } = require('./output');
+
+const HELP = `
+fchek goto <file:line>
+
+Show symbol definition and all references via LSP (batch mode, no editor needed).
+
+Supported languages (auto-detected by extension):
+  .rs         → rust-analyzer
+  .c / .cpp   → clangd
+  .py         → pyright (basedpyright)
+  .ts / .js   → typescript-language-server
+  .cs         → OmniSharp LSP (falls back to grep if not installed)
+                Install OmniSharp: dotnet tool install -g omnisharp
+
+Output: JSON with symbol name, definition location, and references list.
+
+Examples:
+  fchek goto main.rs:42
+  fchek goto src/main.cpp:100
+  fchek goto app.py:17
+  fchek goto src/Program.cs:15
+  fchek goto src/Program.cs:15:8
+`.trim();
+
+const DEFAULT_TIMEOUT_MS = 15_000;
+
+function commandExists(cmd) {
+  try {
+    execSync(
+      process.platform === 'win32' ? `where ${cmd}` : `which ${cmd}`,
+      { stdio: 'ignore' }
+    );
+    return true;
+  } catch { return false; }
+}
+
+function detectLsp(file) {
+  const ext = path.extname(file).toLowerCase();
+  const map = {
+    '.rs':  { server: 'rust-analyzer',              lang: 'rust'       },
+    '.cpp': { server: 'clangd',                      lang: 'cpp'        },
+    '.cc':  { server: 'clangd',                      lang: 'cpp'        },
+    '.c':   { server: 'clangd',                      lang: 'c'          },
+    '.py':  { server: 'pyright',                     lang: 'python'     },
+    '.ts':  { server: 'typescript-language-server',  lang: 'typescript' },
+    '.js':  { server: 'typescript-language-server',  lang: 'javascript' },
+  };
+  return map[ext] || null;
+}
+
+/**
+ * Build a minimal LSP initialize + textDocument/definition request.
+ * We send it over stdin to the LSP server and read stdout.
+ */
+function buildLspRequest(fileUri, line, character, rootUri) {
+  function msg(obj) {
+    const body = JSON.stringify(obj);
+    return `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`;
+  }
+
+  const init = msg({
+    jsonrpc: '2.0', id: 1, method: 'initialize',
+    params: {
+      processId: process.pid,
+      rootUri,
+      capabilities: { textDocument: { definition: {}, references: {} } },
+      initializationOptions: {},
+    },
+  });
+
+  const initialized = msg({
+    jsonrpc: '2.0', method: 'initialized', params: {},
+  });
+
+  const didOpen = msg({
+    jsonrpc: '2.0', method: 'textDocument/didOpen',
+    params: {
+      textDocument: {
+        uri: fileUri,
+        languageId: 'rust', // overridden later — server infers from uri
+        version: 1,
+        text: fs.existsSync(fileUri.replace('file://', ''))
+          ? fs.readFileSync(fileUri.replace('file://', ''), 'utf8')
+          : '',
+      },
+    },
+  });
+
+  const definition = msg({
+    jsonrpc: '2.0', id: 2, method: 'textDocument/definition',
+    params: {
+      textDocument: { uri: fileUri },
+      position: { line: line - 1, character },
+    },
+  });
+
+  const references = msg({
+    jsonrpc: '2.0', id: 3, method: 'textDocument/references',
+    params: {
+      textDocument: { uri: fileUri },
+      position: { line: line - 1, character },
+      context: { includeDeclaration: true },
+    },
+  });
+
+  const shutdown = msg({ jsonrpc: '2.0', id: 99, method: 'shutdown', params: {} });
+
+  return init + initialized + didOpen + definition + references + shutdown;
+}
+
+function parseLspOutput(raw) {
+  const messages = [];
+  let pos = 0;
+  while (pos < raw.length) {
+    const clIdx = raw.indexOf('Content-Length:', pos);
+    if (clIdx === -1) break;
+    const eoh = raw.indexOf('\r\n\r\n', clIdx);
+    if (eoh === -1) break;
+    const len = parseInt(raw.slice(clIdx + 15, eoh).trim(), 10);
+    const body = raw.slice(eoh + 4, eoh + 4 + len);
+    try { messages.push(JSON.parse(body)); } catch {}
+    pos = eoh + 4 + len;
+  }
+  return messages;
+}
+
+function locationToObj(loc) {
+  if (!loc) return null;
+  const file = (loc.uri || '').replace(/^file:\/\//, '');
+  const line = (loc.range && loc.range.start) ? loc.range.start.line + 1 : null;
+  const col  = (loc.range && loc.range.start) ? loc.range.start.character + 1 : null;
+  return { file, line, col };
+}
+
+function findProjectRoot(fromFile) {
+  const markers = ['Cargo.toml', 'package.json', 'CMakeLists.txt', '.git', 'pyproject.toml', '*.csproj', '*.sln'];
+  let dir = path.dirname(path.resolve(fromFile));
+  for (let i = 0; i < 8; i++) {
+    const entries = (() => { try { return fs.readdirSync(dir); } catch { return []; } })();
+    if (entries.some(e =>
+      e === 'Cargo.toml' || e === 'package.json' || e === 'CMakeLists.txt' ||
+      e === '.git' || e === 'pyproject.toml' || e.endsWith('.csproj') || e.endsWith('.sln')
+    )) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return path.dirname(path.resolve(fromFile));
+}
+
+// ─── OmniSharp LSP request builder ───────────────────────────────────────────
+
+function buildOmniSharpRequest(fileUri, filePath, lineNum, colNum, rootPath) {
+  function msg(obj) {
+    const body = JSON.stringify(obj);
+    return `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`;
+  }
+
+  const fileContent = (() => { try { return fs.readFileSync(filePath, 'utf8'); } catch { return ''; } })();
+
+  const init = msg({
+    jsonrpc: '2.0', id: 1, method: 'initialize',
+    params: {
+      processId: process.pid,
+      rootUri: `file://${rootPath.replace(/\\/g, '/')}`,
+      rootPath,
+      capabilities: {
+        textDocument: {
+          definition: { dynamicRegistration: false },
+          references: { dynamicRegistration: false },
+          hover:      { dynamicRegistration: false },
+          synchronization: { dynamicRegistration: false },
+        },
+        workspace: { applyEdit: false },
+      },
+      initializationOptions: {
+        AutomaticWorkspaceInit: true,
+      },
+    },
+  });
+
+  const initialized = msg({ jsonrpc: '2.0', method: 'initialized', params: {} });
+
+  const didOpen = msg({
+    jsonrpc: '2.0', method: 'textDocument/didOpen',
+    params: {
+      textDocument: {
+        uri: fileUri,
+        languageId: 'csharp',
+        version: 1,
+        text: fileContent,
+      },
+    },
+  });
+
+  // Small delay to let OmniSharp analyze — send a dummy hover first
+  const hover = msg({
+    jsonrpc: '2.0', id: 10, method: 'textDocument/hover',
+    params: {
+      textDocument: { uri: fileUri },
+      position: { line: lineNum - 1, character: Math.max(0, colNum - 1) },
+    },
+  });
+
+  const definition = msg({
+    jsonrpc: '2.0', id: 2, method: 'textDocument/definition',
+    params: {
+      textDocument: { uri: fileUri },
+      position: { line: lineNum - 1, character: Math.max(0, colNum - 1) },
+    },
+  });
+
+  const references = msg({
+    jsonrpc: '2.0', id: 3, method: 'textDocument/references',
+    params: {
+      textDocument: { uri: fileUri },
+      position: { line: lineNum - 1, character: Math.max(0, colNum - 1) },
+      context: { includeDeclaration: true },
+    },
+  });
+
+  const shutdown = msg({ jsonrpc: '2.0', id: 99, method: 'shutdown', params: {} });
+
+  return init + initialized + didOpen + hover + definition + references + shutdown;
+}
+
+/**
+ * Find OmniSharp executable — checks:
+ *  1. omnisharp  (if installed via dotnet tool install -g omnisharp)
+ *  2. OmniSharp  (Windows capitalisation)
+ *  3. dotnet omnisharp (nuget global tool)
+ */
+function findOmniSharp() {
+  for (const cmd of ['omnisharp', 'OmniSharp', 'OmniSharp.exe']) {
+    try {
+      execSync(process.platform === 'win32' ? `where ${cmd}` : `which ${cmd}`,
+        { stdio: 'ignore', timeout: 3000 });
+      return { cmd, args: ['--languageserver'] };
+    } catch {}
+  }
+  // Check dotnet tool: dotnet tool list -g
+  try {
+    const res = execSync('dotnet tool list -g', { encoding: 'utf8', timeout: 5000 });
+    if (/omnisharp/i.test(res)) {
+      return { cmd: 'omnisharp', args: ['--languageserver'] };
+    }
+  } catch {}
+  return null;
+}
+
+// ─── C# grep-based fallback ───────────────────────────────────────────────────
+
+function grepCSharpSymbol(filePath, line, col) {
+  const content = fs.readFileSync(filePath, 'utf8');
+  const lines = content.split('\n');
+  const targetLine = lines[line - 1] || '';
+
+  const CSHARP_KEYWORDS = new Set([
+    'public','private','protected','internal','static','readonly','const','abstract',
+    'virtual','override','sealed','partial','async','await','new','return','using',
+    'namespace','class','interface','struct','enum','record','void','var','let',
+    'if','else','for','foreach','while','do','switch','case','break','continue',
+    'try','catch','finally','throw','in','out','ref','params','this','base',
+    'true','false','null','string','int','long','bool','double','float','object',
+    'Task','List','Dictionary','IEnumerable','IList','IReadOnlyList',
+  ]);
+
+  let symbol = null;
+
+  if (col > 0) {
+    const slice = targetLine.slice(Math.max(0, col - 1));
+    const m = slice.match(/^([A-Za-z_]\w*)/);
+    if (m && !CSHARP_KEYWORDS.has(m[1])) symbol = m[1];
+  }
+
+  if (!symbol) {
+    const allTokens = [...targetLine.matchAll(/\b([A-Za-z_]\w*)\b/g)];
+    for (const tok of allTokens) {
+      if (!CSHARP_KEYWORDS.has(tok[1])) { symbol = tok[1]; break; }
+    }
+  }
+
+  if (!symbol) {
+    for (const offset of [1, -1, 2, -2]) {
+      const adjLine = lines[line - 1 + offset] || '';
+      const tokens = [...adjLine.matchAll(/\b([A-Za-z_]\w*)\b/g)];
+      for (const tok of tokens) {
+        if (!CSHARP_KEYWORDS.has(tok[1])) { symbol = tok[1]; break; }
+      }
+      if (symbol) break;
+    }
+  }
+
+  if (!symbol) {
+    return { error: `No symbol found at ${filePath}:${line}:${col}` };
+  }
+
+  const projectDir = findProjectRoot(filePath);
+  const csFiles = [];
+  function walkCs(dir) {
+    try {
+      for (const name of fs.readdirSync(dir)) {
+        if (['bin', 'obj', '.git', 'node_modules'].includes(name)) continue;
+        const full = path.join(dir, name);
+        if (fs.statSync(full).isDirectory()) walkCs(full);
+        else if (name.endsWith('.cs')) csFiles.push(full);
+      }
+    } catch {}
+  }
+  walkCs(projectDir);
+
+  const definitions = [];
+  const references = [];
+  const defPattern = new RegExp(
+    `(?:class|interface|record|struct|enum|void|async|public|private|protected)\\s+${symbol}\\b|\\b${symbol}\\s*\\(`
+  );
+  const refPattern = new RegExp(`\\b${symbol}\\b`);
+
+  for (const csFile of csFiles) {
+    const src = fs.readFileSync(csFile, 'utf8').split('\n');
+    for (let i = 0; i < src.length; i++) {
+      const srcLine = src[i];
+      if (defPattern.test(srcLine)) {
+        definitions.push({ file: csFile, line: i + 1, text: srcLine.trim().slice(0, 100) });
+      } else if (refPattern.test(srcLine)) {
+        references.push({ file: csFile, line: i + 1, text: srcLine.trim().slice(0, 80) });
+      }
+    }
+  }
+
+  return {
+    symbol,
+    projectDir,
+    definitions,
+    references,
+  };
+}
+
+// ─── Main C# goto handler ────────────────────────────────────────────────────
+
+async function gotoCSharp(filePath, line, col) {
+  const absFile    = path.resolve(filePath);
+  const rootDir    = findProjectRoot(absFile);
+  const fileUri    = `file://${absFile.replace(/\\/g, '/')}`;
+  const omnisharp  = findOmniSharp();
+
+  // ── Try OmniSharp LSP first ──────────────────────────────────────────────
+  if (omnisharp) {
+    const input = buildOmniSharpRequest(fileUri, absFile, line, col, rootDir);
+
+    const res = spawnSync(omnisharp.cmd, omnisharp.args, {
+      input,
+      encoding:    'utf8',
+      timeout:     DEFAULT_TIMEOUT_MS,
+      windowsHide: true,
+    });
+
+    if (!res.error && res.stdout) {
+      const messages = parseLspOutput(res.stdout);
+
+      let definitionResult = null;
+      let referencesResult = null;
+
+      for (const msg of messages) {
+        if (msg.id === 2 && msg.result !== undefined) {
+          const r = Array.isArray(msg.result) ? msg.result[0] : msg.result;
+          if (r) definitionResult = locationToObj(r);
+        }
+        if (msg.id === 3 && Array.isArray(msg.result)) {
+          referencesResult = msg.result.map(locationToObj).filter(Boolean);
+        }
+      }
+
+      // If LSP returned at least a definition, use it
+      if (definitionResult || referencesResult) {
+        return output(ok({
+          query: { file: absFile, line, col },
+          lsp: {
+            server:     omnisharp.cmd,
+            language:   'csharp',
+            root:       rootDir,
+            timeout_ms: DEFAULT_TIMEOUT_MS,
+          },
+          definition:  definitionResult,
+          references:  referencesResult || [],
+          ref_count:   referencesResult ? referencesResult.length : 0,
+        }));
+      }
+    }
+
+    // OmniSharp found but returned nothing — fall through to grep with a note
+    const grep = grepCSharpSymbol(filePath, line, col);
+    if (grep.error) return output(fail(grep.error));
+
+    return output(ok({
+      query: { file: absFile, line, col },
+      lsp: {
+        server:   omnisharp.cmd,
+        language: 'csharp',
+        root:     rootDir,
+        note:     'OmniSharp did not return results (project may still be loading). Fell back to grep.',
+      },
+      symbol:          grep.symbol,
+      definition:      grep.definitions[0] || null,
+      all_definitions: grep.definitions.slice(0, 5),
+      references:      grep.references.slice(0, 30),
+      ref_count:       grep.references.length,
+      fallback:        'grep',
+    }));
+  }
+
+  // ── OmniSharp not installed — use grep fallback ──────────────────────────
+  const grep = grepCSharpSymbol(filePath, line, col);
+  if (grep.error) return output(fail(grep.error));
+
+  return output(ok({
+    query: { file: absFile, line, col },
+    lsp: {
+      server:   'grep-fallback',
+      language: 'csharp',
+      root:     grep.projectDir,
+      note:     'OmniSharp not found. Install for full LSP: dotnet tool install -g omnisharp',
+    },
+    symbol:          grep.symbol,
+    definition:      grep.definitions[0] || null,
+    all_definitions: grep.definitions.slice(0, 5),
+    references:      grep.references.slice(0, 30),
+    ref_count:       grep.references.length,
+    fallback:        'grep',
+  }));
+}
+
+async function run(args) {
+  if (args.length === 0 || args[0] === '--help') {
+    console.log(HELP);
+    return;
+  }
+
+  const target = args[0];
+  const match  = target.match(/^(.+):(\d+)(?::(\d+))?$/);
+  if (!match) {
+    return output(fail(`Bad format: "${target}". Expected file:line or file:line:col`));
+  }
+
+  const filePath  = match[1];
+  const lineNum   = parseInt(match[2], 10);
+  const colNum    = parseInt(match[3] || '0', 10);
+
+  if (!fs.existsSync(filePath)) {
+    return output(fail(`File not found: ${filePath}`));
+  }
+
+  // C# — OmniSharp LSP with grep fallback
+  if (path.extname(filePath).toLowerCase() === '.cs') {
+    return gotoCSharp(filePath, lineNum, colNum);
+  }
+
+  const lspInfo = detectLsp(filePath);
+  if (!lspInfo) {
+    return output(fail(`No LSP server for extension: ${path.extname(filePath)}`));
+  }
+
+  if (!commandExists(lspInfo.server)) {
+    return output(fail(
+      `LSP server not found: ${lspInfo.server}\n` +
+      `Install it and ensure it is on PATH.`
+    ));
+  }
+
+  const absFile = path.resolve(filePath);
+  const rootDir = detectProjectRoot(absFile);
+  const fileUri = `file://${absFile.replace(/\\/g, '/')}`;
+  const rootUri = `file://${rootDir.replace(/\\/g, '/')}`;
+
+  const input  = buildLspRequest(fileUri, lineNum, colNum, rootUri);
+
+  // rust-analyzer needs --stdio flag; clangd & pyright work without args by default
+  const serverArgs = lspInfo.server === 'rust-analyzer' ? ['--stdio'] : [];
+  const serverRes  = spawnSync(lspInfo.server, serverArgs, {
+    input,
+    encoding: 'utf8',
+    timeout:  DEFAULT_TIMEOUT_MS,
+  });
+
+  if (serverRes.error) {
+    if (serverRes.error.code === 'ETIMEDOUT') {
+      return output(fail(`LSP server timed out after ${DEFAULT_TIMEOUT_MS}ms`));
+    }
+    return output(fail(`LSP server error: ${serverRes.error.message}`));
+  }
+
+  const messages = parseLspOutput(serverRes.stdout || '');
+
+  let definitionResult = null;
+  let referencesResult = null;
+
+  for (const msg of messages) {
+    if (msg.id === 2 && msg.result !== undefined) {
+      const r = Array.isArray(msg.result) ? msg.result[0] : msg.result;
+      definitionResult = locationToObj(r);
+    }
+    if (msg.id === 3 && Array.isArray(msg.result)) {
+      referencesResult = msg.result.map(locationToObj).filter(Boolean);
+    }
+  }
+
+  output(ok({
+    query: {
+      file: absFile,
+      line: lineNum,
+      col:  colNum,
+    },
+    lsp: {
+      server:     lspInfo.server,
+      language:   lspInfo.lang,
+      root:       rootDir,
+      timeout_ms: DEFAULT_TIMEOUT_MS,
+    },
+    definition:  definitionResult,
+    references:  referencesResult || [],
+    ref_count:   referencesResult ? referencesResult.length : 0,
+  }));
+}
+
+function detectProjectRoot(fromFile) {
+  const markers = ['Cargo.toml', 'package.json', 'CMakeLists.txt', '.git', 'pyproject.toml'];
+  let dir = path.dirname(fromFile);
+  for (let i = 0; i < 8; i++) {
+    if (markers.some(m => fs.existsSync(path.join(dir, m)))) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return path.dirname(fromFile);
+}
+
+module.exports = { run };