fchek 1.0.0

package/lib/context.js

@@ -0,0 +1,356 @@
+'use strict';
+
+/**
+ * context.js — dump all functions/classes/symbols in a project
+ *
+ * Prevents AI from creating duplicate names or missing existing abstractions.
+ * Uses AST parsing per language, falls back to regex grep.
+ *
+ * Call this BEFORE writing new code in an existing project.
+ */
+
+const { spawnSync } = require('child_process');
+const path = require('path');
+const fs   = require('fs');
+const { output, ok, fail } = require('./output');
+const { findPython } = require('./python');
+
+const HELP = `
+fchek context <file_or_dir> [--lang=auto] [--names-only] [--json]
+
+Dump all functions, classes, methods and exports in a project.
+Call this BEFORE writing new code to avoid naming conflicts and duplicates.
+
+Options:
+  --names-only   Output just symbol names (compact list)
+  --depth=N      Max directory depth (default: 5)
+
+Examples:
+  fchek context src/
+  fchek context main.py
+  fchek context . --names-only
+  fchek context src/auth.rs
+`.trim();
+
+const IGNORED_DIRS = new Set(['node_modules', '.git', 'dist', 'build', 'target', '__pycache__', '.venv', 'vendor']);
+
+// ─── AST extraction per language ─────────────────────────────────────────────
+
+/** Python: use ast module via subprocess for accurate extraction.
+ *  Script is written to a tmpfile to avoid sys.argv[1] confusion with -c mode.
+ */
+function extractPython(filePath) {
+  const os = require('os');
+  const absPath = path.resolve(filePath);
+
+  // Escape backslashes for embedding in Python string literal (Windows paths)
+  const escapedPath = absPath.replace(/\\/g, '\\\\');
+
+  const script = `
+import ast, json, sys
+
+TARGET = ${JSON.stringify(absPath)}
+
+try:
+    with open(TARGET, encoding='utf-8', errors='replace') as f:
+        src = f.read()
+    tree = ast.parse(src, filename=TARGET)
+except SyntaxError as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(0)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(0)
+
+symbols = []
+for node in ast.walk(tree):
+    if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+        symbols.append({
+            "kind": "function" if isinstance(node, ast.FunctionDef) else "async_function",
+            "name": node.name,
+            "line": node.lineno,
+            "args": [a.arg for a in node.args.args]
+        })
+    elif isinstance(node, ast.ClassDef):
+        methods = [
+            n.name for n in ast.walk(node)
+            if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))
+            and n.col_offset > 0
+        ]
+        symbols.append({
+            "kind": "class",
+            "name": node.name,
+            "line": node.lineno,
+            "methods": methods
+        })
+print(json.dumps(symbols))
+`.trim();
+
+  // Write script to tmpfile — avoids any sys.argv / -c interaction issues
+  const tmpScript = path.join(os.tmpdir(), `fchek_ast_${process.pid}.py`);
+  try {
+    fs.writeFileSync(tmpScript, script, 'utf8');
+  } catch (e) {
+    return [];
+  }
+
+  const py = findPython();
+
+  if (!py) {
+    try { fs.unlinkSync(tmpScript); } catch {}
+    return [];
+  }
+
+  const res = spawnSync(py, [tmpScript], { encoding: 'utf8', timeout: 15000, windowsHide: true });
+  try { fs.unlinkSync(tmpScript); } catch {}
+
+  if (res.error || !res.stdout) return [];
+  try { return JSON.parse(res.stdout.trim()); } catch { return []; }
+}
+
+/** JavaScript/TypeScript: regex-based extraction (reliable, no deps) */
+function extractJs(filePath) {
+  const src = readFile(filePath);
+  if (!src) return [];
+  const symbols = [];
+  const lines = src.split('\n');
+
+  lines.forEach((line, i) => {
+    const ln = i + 1;
+    // function declarations
+    let m = line.match(/^(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(/);
+    if (m) { symbols.push({ kind: 'function', name: m[1], line: ln }); return; }
+    // arrow functions assigned to const/let
+    m = line.match(/^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?\(/);
+    if (m) { symbols.push({ kind: 'arrow_function', name: m[1], line: ln }); return; }
+    // class declarations
+    m = line.match(/^(?:export\s+)?(?:abstract\s+)?class\s+(\w+)/);
+    if (m) { symbols.push({ kind: 'class', name: m[1], line: ln }); return; }
+    // class methods
+    m = line.match(/^\s{2,}(?:async\s+)?(?:static\s+)?(?:get\s+|set\s+)?(\w+)\s*\([^)]*\)\s*(?::\s*\w+\s*)?\{/);
+    if (m && !['if', 'for', 'while', 'switch', 'catch'].includes(m[1])) {
+      symbols.push({ kind: 'method', name: m[1], line: ln }); return;
+    }
+    // module.exports
+    m = line.match(/module\.exports\s*=\s*\{([^}]+)\}/);
+    if (m) {
+      const names = m[1].split(',').map(s => s.trim().split(':')[0].trim()).filter(Boolean);
+      names.forEach(name => symbols.push({ kind: 'export', name, line: ln }));
+    }
+  });
+
+  return symbols;
+}
+
+/** Rust: regex-based extraction */
+function extractRust(filePath) {
+  const src = readFile(filePath);
+  if (!src) return [];
+  const symbols = [];
+  const lines = src.split('\n');
+
+  lines.forEach((line, i) => {
+    const ln = i + 1;
+    let m = line.match(/^(?:pub(?:\([\w:]+\))?\s+)?(?:async\s+)?fn\s+(\w+)/);
+    if (m) { symbols.push({ kind: 'function', name: m[1], line: ln }); return; }
+    m = line.match(/^(?:pub(?:\([\w:]+\))?\s+)?struct\s+(\w+)/);
+    if (m) { symbols.push({ kind: 'struct', name: m[1], line: ln }); return; }
+    m = line.match(/^(?:pub(?:\([\w:]+\))?\s+)?enum\s+(\w+)/);
+    if (m) { symbols.push({ kind: 'enum', name: m[1], line: ln }); return; }
+    m = line.match(/^(?:pub(?:\([\w:]+\))?\s+)?trait\s+(\w+)/);
+    if (m) { symbols.push({ kind: 'trait', name: m[1], line: ln }); return; }
+    m = line.match(/^(?:pub(?:\([\w:]+\))?\s+)?impl(?:<[^>]+>)?\s+(?:\w+\s+for\s+)?(\w+)/);
+    if (m) { symbols.push({ kind: 'impl', name: m[1], line: ln }); return; }
+    m = line.match(/^(?:pub(?:\([\w:]+\))?\s+)?(?:type|const)\s+(\w+)/);
+    if (m) { symbols.push({ kind: 'type_or_const', name: m[1], line: ln }); }
+  });
+
+  return symbols;
+}
+
+/** C/C++: regex-based */
+function extractC(filePath) {
+  const src = readFile(filePath);
+  if (!src) return [];
+  const symbols = [];
+  const lines = src.split('\n');
+
+  lines.forEach((line, i) => {
+    const ln = i + 1;
+    // function definitions: type name(...)
+    let m = line.match(/^(?:static\s+|inline\s+|extern\s+)?(?:[\w:*&<>]+\s+)+(\w+)\s*\([^;]*\)\s*(?:const\s*)?(?:override\s*)?(?:noexcept\s*)?\{?\s*$/);
+    if (m && !['if', 'for', 'while', 'switch', 'else', 'return'].includes(m[1])) {
+      symbols.push({ kind: 'function', name: m[1], line: ln }); return;
+    }
+    // class/struct
+    m = line.match(/^(?:class|struct)\s+(\w+)/);
+    if (m) { symbols.push({ kind: line.startsWith('class') ? 'class' : 'struct', name: m[1], line: ln }); return; }
+    // #define macros
+    m = line.match(/^#define\s+(\w+)/);
+    if (m) { symbols.push({ kind: 'macro', name: m[1], line: ln }); }
+  });
+
+  return symbols;
+}
+
+/** Go: regex-based */
+function extractGo(filePath) {
+  const src = readFile(filePath);
+  if (!src) return [];
+  const symbols = [];
+  const lines = src.split('\n');
+
+  lines.forEach((line, i) => {
+    const ln = i + 1;
+    let m = line.match(/^func\s+(?:\(\w+\s+\*?\w+\)\s+)?(\w+)\s*\(/);
+    if (m) { symbols.push({ kind: 'function', name: m[1], line: ln }); return; }
+    m = line.match(/^type\s+(\w+)\s+(?:struct|interface)/);
+    if (m) { symbols.push({ kind: line.includes('struct') ? 'struct' : 'interface', name: m[1], line: ln }); }
+  });
+
+  return symbols;
+}
+
+/** C#: regex-based */
+function extractCSharp(filePath) {
+  const src = readFile(filePath);
+  if (!src) return [];
+  const symbols = [];
+  const lines = src.split('\n');
+
+  lines.forEach((line, i) => {
+    const ln = i + 1;
+    // class / interface / record / struct / enum
+    let m = line.match(/^\s*(?:public|private|protected|internal|static|abstract|sealed|partial|\s)*\s+(class|interface|record|struct|enum)\s+(\w+)/);
+    if (m) { symbols.push({ kind: m[1], name: m[2], line: ln }); return; }
+    // methods: visibility returnType name(
+    m = line.match(/^\s*(?:public|private|protected|internal|static|async|override|virtual|abstract|\s)+(?:[\w<>\[\]?]+\s+)+(\w+)\s*\(/);
+    if (m && !['if', 'for', 'while', 'switch', 'catch', 'using', 'return'].includes(m[1])) {
+      symbols.push({ kind: 'method', name: m[1], line: ln }); return;
+    }
+    // properties
+    m = line.match(/^\s*(?:public|private|protected|internal|static|\s)+(?:[\w<>\[\]?]+\s+)+(\w+)\s*\{[^}]*get/);
+    if (m) { symbols.push({ kind: 'property', name: m[1], line: ln }); }
+  });
+
+  return symbols;
+}
+
+// ─── File walker ─────────────────────────────────────────────────────────────
+
+function readFile(p) {
+  try { return fs.readFileSync(p, 'utf8'); } catch { return null; }
+}
+
+const EXT_MAP = {
+  '.py': 'python', '.js': 'javascript', '.mjs': 'javascript', '.cjs': 'javascript',
+  '.ts': 'typescript', '.tsx': 'typescript', '.jsx': 'javascript',
+  '.rs': 'rust', '.c': 'c', '.cpp': 'c', '.cc': 'c', '.h': 'c', '.hpp': 'c',
+  '.go': 'go',
+  '.cs': 'csharp', '.vb': 'csharp',
+};
+
+function extractFile(filePath) {
+  const ext  = path.extname(filePath).toLowerCase();
+  const lang = EXT_MAP[ext];
+  if (!lang) return null;
+
+  let symbols;
+  if (lang === 'python')                        symbols = extractPython(filePath);
+  else if (lang === 'javascript' || lang === 'typescript') symbols = extractJs(filePath);
+  else if (lang === 'rust')                     symbols = extractRust(filePath);
+  else if (lang === 'c')                        symbols = extractC(filePath);
+  else if (lang === 'go')                       symbols = extractGo(filePath);
+  else if (lang === 'csharp')                   symbols = extractCSharp(filePath);
+  else return null;
+
+  if (!Array.isArray(symbols) || symbols.length === 0) return null;
+
+  return { file: filePath, lang, symbols };
+}
+
+function walkDir(dir, depth, maxDepth) {
+  if (depth > maxDepth) return [];
+  const results = [];
+  let entries;
+  try { entries = fs.readdirSync(dir); } catch { return []; }
+
+  for (const name of entries) {
+    if (IGNORED_DIRS.has(name) || name.startsWith('.')) continue;
+    const full = path.join(dir, name);
+    const stat = fs.statSync(full);
+    if (stat.isDirectory()) {
+      results.push(...walkDir(full, depth + 1, maxDepth));
+    } else if (stat.isFile()) {
+      const r = extractFile(full);
+      if (r) results.push(r);
+    }
+  }
+  return results;
+}
+
+// ─── Entry point ─────────────────────────────────────────────────────────────
+
+async function run(args) {
+  if (args.length === 0 || args[0] === '--help') { console.log(HELP); return; }
+
+  const target    = args[0];
+  const namesOnly = args.includes('--names-only');
+  const depthArg  = parseInt((args.find(a => a.startsWith('--depth=')) || '--depth=5').replace('--depth=', ''), 10);
+
+  if (!fs.existsSync(target)) {
+    return output(fail(`Not found: ${target}`));
+  }
+
+  const stat  = fs.statSync(target);
+  const files = [];
+
+  if (stat.isDirectory()) {
+    files.push(...walkDir(path.resolve(target), 0, depthArg));
+  } else {
+    const r = extractFile(path.resolve(target));
+    if (r) files.push(r);
+    else return output(fail(`Unsupported file type: ${path.extname(target)}`));
+  }
+
+  if (files.length === 0) {
+    return output(fail(`No supported source files found in: ${target}`));
+  }
+
+  const totalSymbols = files.reduce((n, f) => n + f.symbols.length, 0);
+
+  // Build flat name index for quick duplicate detection
+  const nameIndex = {};
+  for (const file of files) {
+    for (const sym of file.symbols) {
+      if (!nameIndex[sym.name]) nameIndex[sym.name] = [];
+      nameIndex[sym.name].push({ file: file.file, kind: sym.kind, line: sym.line });
+    }
+  }
+
+  // Detect duplicate names across files
+  const duplicates = Object.entries(nameIndex)
+    .filter(([, locs]) => locs.length > 1)
+    .map(([name, locs]) => ({ name, locations: locs }));
+
+  if (namesOnly) {
+    output(ok({
+      target,
+      total_files:   files.length,
+      total_symbols: totalSymbols,
+      names:         Object.keys(nameIndex).sort(),
+      duplicates:    duplicates.slice(0, 20),
+    }));
+  } else {
+    output(ok({
+      target,
+      total_files:   files.length,
+      total_symbols: totalSymbols,
+      files,
+      name_index:    nameIndex,
+      duplicates:    duplicates.slice(0, 20),
+    }));
+  }
+}
+
+module.exports = { run };