fchek 1.0.0

package/lib/db.js

@@ -0,0 +1,135 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { output, ok, fail } = require('./output');
+
+const HELP = `
+fchek db schema <db_path>
+fchek db query <db_path> <sql_query>
+
+Inspect and query SQLite databases.
+schema: List all tables, columns, types, primary keys, and indexes.
+query: Execute a SELECT or action query and return results.
+`.trim();
+
+// Try to load Node.js 22 built-in sqlite module
+let DatabaseSync;
+try {
+  DatabaseSync = require('node:sqlite').DatabaseSync;
+} catch (err) {
+  // node:sqlite not available (<22.5.0 or older Node)
+}
+
+function runSqliteCommand(dbPath, sql) {
+  // If sqlite3 CLI tool is installed, we can fall back to it
+  const { execSync } = require('child_process');
+  try {
+    const jsonOut = execSync(`sqlite3 "${dbPath}" -json "${sql}"`, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    return JSON.parse(jsonOut.trim() || '[]');
+  } catch (err) {
+    throw new Error('SQLite query failed. Make sure sqlite3 CLI tool is in your PATH or use Node.js >= 22.5');
+  }
+}
+
+async function run(args) {
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(HELP);
+    return;
+  }
+
+  const action = args[0];
+  const dbPath = args[1];
+
+  if (!action || !['schema', 'query'].includes(action)) {
+    output(fail('Invalid action. Use "schema" or "query"', 'db'));
+    return;
+  }
+
+  if (!dbPath) {
+    output(fail('Please specify a database file path', 'db'));
+    return;
+  }
+
+  const resolvedPath = path.resolve(dbPath);
+  if (!fs.existsSync(resolvedPath)) {
+    output(fail(`Database file does not exist: ${dbPath}`, 'db'));
+    return;
+  }
+
+  if (action === 'schema') {
+    try {
+      let tables = [];
+      if (DatabaseSync) {
+        const db = new DatabaseSync(resolvedPath);
+        const tablesRows = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'").all();
+        
+        for (const tRow of tablesRows) {
+          const tableName = tRow.name;
+          const colRows = db.prepare(`PRAGMA table_info("${tableName}")`).all();
+          const indexRows = db.prepare(`PRAGMA index_list("${tableName}")`).all();
+          
+          const columns = colRows.map(c => ({
+            name: c.name,
+            type: c.type,
+            notnull: c.notnull === 1,
+            dflt_value: c.dflt_value,
+            pk: c.pk === 1
+          }));
+
+          tables.push({
+            name: tableName,
+            columns,
+            indexes: indexRows.map(i => i.name)
+          });
+        }
+        db.close();
+      } else {
+        // Fallback using sqlite3 CLI
+        const tablesRows = runSqliteCommand(resolvedPath, "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'");
+        for (const tRow of tablesRows) {
+          const tableName = tRow.name;
+          const colRows = runSqliteCommand(resolvedPath, `PRAGMA table_info("${tableName}")`);
+          const indexRows = runSqliteCommand(resolvedPath, `PRAGMA index_list("${tableName}")`);
+          tables.push({
+            name: tableName,
+            columns: colRows.map(c => ({
+              name: c.name,
+              type: c.type,
+              notnull: c.notnull === 1,
+              dflt_value: c.dflt_value,
+              pk: c.pk === 1
+            })),
+            indexes: indexRows.map(i => i.name)
+          });
+        }
+      }
+      output(ok({ database: dbPath, tables }, 'db'));
+    } catch (err) {
+      output(fail(`Failed to fetch schema: ${err.message}`, 'db'));
+    }
+  } else if (action === 'query') {
+    const querySql = args.slice(2).join(' ');
+    if (!querySql) {
+      output(fail('Please specify a SQL query', 'db'));
+      return;
+    }
+
+    try {
+      let rows = [];
+      if (DatabaseSync) {
+        const db = new DatabaseSync(resolvedPath);
+        const stmt = db.prepare(querySql);
+        rows = stmt.all();
+        db.close();
+      } else {
+        rows = runSqliteCommand(resolvedPath, querySql);
+      }
+      output(ok({ query: querySql, count: rows.length, rows }, 'db'));
+    } catch (err) {
+      output(fail(`Query execution failed: ${err.message}`, 'db'));
+    }
+  }
+}
+
+module.exports = { run };

package/lib/deps-check.js

@@ -0,0 +1,264 @@
+'use strict';
+
+/**
+ * deps-check.js — check library API freshness
+ *
+ * Fetches current package metadata from npm / PyPI / crates.io
+ * and compares against what's installed in the project.
+ * Closes the "hallucinated API" problem.
+ */
+
+const { spawnSync, execSync } = require('child_process');
+const https  = require('https');
+const path   = require('path');
+const fs     = require('fs');
+const { output, ok, fail } = require('./output');
+
+const HELP = `
+fchek deps-check <lib> [--lang=auto] [--show-changelog]
+
+Check if a library's API is current. Fetches live data from package registries.
+Tells you: installed version, latest version, deprecated APIs, what to use instead.
+
+Supported registries:
+  npm       → https://registry.npmjs.org
+  PyPI      → https://pypi.org/pypi
+  crates.io → https://crates.io/api/v1/crates
+
+Options:
+  --lang=node|python|rust   Force language (default: auto-detect from project)
+  --show-changelog          Include changelog URL if available
+
+Examples:
+  fchek deps-check express
+  fchek deps-check requests --lang=python
+  fchek deps-check serde --lang=rust
+`.trim();
+
+function fetchJson(url, timeoutMs = 15000) {
+  return new Promise((resolve, reject) => {
+    const req = https.get(url, {
+      headers: { 'User-Agent': 'fchek/1.0', Accept: 'application/json' },
+      timeout: timeoutMs,
+    }, (res) => {
+      let data = '';
+      res.on('data', c => { data += c; });
+      res.on('end', () => {
+        try { resolve(JSON.parse(data)); }
+        catch (e) { reject(new Error(`JSON parse failed: ${e.message}`)); }
+      });
+    });
+    req.on('error', (err) => {
+      // Provide actionable error messages for common network issues
+      if (err.code === 'ECONNREFUSED' || err.code === 'ECONNRESET') {
+        reject(new Error(`No connection to registry. Check your internet connection.`));
+      } else if (err.code === 'ENOTFOUND') {
+        reject(new Error(`DNS lookup failed for registry. Check internet connection or DNS settings.`));
+      } else if (err.code === 'ETIMEDOUT') {
+        reject(new Error(`Registry request timed out. Check internet connection.`));
+      } else {
+        reject(err);
+      }
+    });
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error(`Registry request timed out after ${timeoutMs}ms. Check internet connection.`));
+    });
+  });
+}
+
+/** Offline fallback: read installed version from local project files only */
+function offlineFallback(lib, lang, cwd) {
+  let installed = null;
+
+  if (lang === 'node') {
+    installed = installedNode(lib, cwd);
+    // Also try reading from package.json directly
+    if (!installed) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
+        installed = pkg.dependencies?.[lib] || pkg.devDependencies?.[lib] || null;
+      } catch {}
+    }
+  } else if (lang === 'python') {
+    installed = installedPython(lib);
+  } else if (lang === 'rust') {
+    // Read from Cargo.toml directly
+    try {
+      const cargo = fs.readFileSync(path.join(cwd, 'Cargo.toml'), 'utf8');
+      const m = cargo.match(new RegExp(`${lib}\\s*=\\s*["{]([0-9][^"{}\\n]+)`, 'i'));
+      installed = m?.[1]?.trim() || installedRust(lib, cwd);
+    } catch { installed = installedRust(lib, cwd); }
+  }
+
+  return {
+    lib,
+    registry: lang === 'node' ? 'npm' : lang === 'python' ? 'pypi' : 'crates.io',
+    offline:  true,
+    offline_note: 'No internet connection. Showing installed version only. Cannot check for latest/deprecated.',
+    installed_version: installed,
+    latest_version:    null,
+    up_to_date:        null,
+  };
+}
+
+function detectLang(cwd) {
+  if (fs.existsSync(path.join(cwd, 'package.json')))  return 'node';
+  if (fs.existsSync(path.join(cwd, 'Cargo.toml')))    return 'rust';
+  if (fs.existsSync(path.join(cwd, 'requirements.txt'))
+   || fs.existsSync(path.join(cwd, 'pyproject.toml'))
+   || fs.existsSync(path.join(cwd, 'setup.py')))      return 'python';
+  return null;
+}
+
+function installedNode(lib, cwd) {
+  try {
+    const p = path.join(cwd, 'node_modules', lib, 'package.json');
+    if (fs.existsSync(p)) return JSON.parse(fs.readFileSync(p, 'utf8')).version || null;
+  } catch {}
+  try {
+    const r = spawnSync('npm', ['list', lib, '--depth=0', '--json'], { encoding: 'utf8', cwd, timeout: 8000 });
+    return JSON.parse(r.stdout || '{}')?.dependencies?.[lib]?.version || null;
+  } catch { return null; }
+}
+
+function installedPython(lib) {
+  try {
+    return execSync(`python3 -c "import importlib.metadata;print(importlib.metadata.version('${lib}'))"`,
+      { encoding: 'utf8', timeout: 5000 }).trim() || null;
+  } catch {
+    try {
+      return execSync(`pip show ${lib}`, { encoding: 'utf8', timeout: 5000 })
+        .match(/Version:\s*(.+)/)?.[1]?.trim() || null;
+    } catch { return null; }
+  }
+}
+
+function installedRust(lib, cwd) {
+  try {
+    const r = spawnSync('cargo', ['metadata', '--no-deps', '--format-version=1'],
+      { encoding: 'utf8', cwd, timeout: 15000 });
+    const data = JSON.parse(r.stdout || '{}');
+    for (const pkg of data.packages || []) {
+      if (pkg.name === lib) return pkg.version;
+      for (const dep of pkg.dependencies || []) {
+        if (dep.name === lib) return dep.req?.replace(/[^0-9.]/, '') || null;
+      }
+    }
+  } catch {}
+  return null;
+}
+
+async function checkNpm(lib, showChangelog) {
+  const cwd       = process.cwd();
+  const installed = installedNode(lib, cwd);
+  const data      = await fetchJson(`https://registry.npmjs.org/${encodeURIComponent(lib)}`);
+  const latest    = data['dist-tags']?.latest || null;
+  const latestMeta = data.versions?.[latest] || {};
+
+  const deprecated = [];
+  for (const [ver, meta] of Object.entries(data.versions || {})) {
+    if (meta.deprecated) deprecated.push({ version: ver, message: meta.deprecated });
+  }
+
+  const installedDeprecated = installed
+    ? (data.versions?.[installed]?.deprecated || null)
+    : null;
+
+  return {
+    lib, registry: 'npm',
+    installed_version:    installed,
+    latest_version:       latest,
+    up_to_date:           installed === latest,
+    installed_deprecated: installedDeprecated,
+    deprecated_versions:  deprecated.slice(0, 10),
+    recent_versions:      Object.keys(data.versions || {}).slice(-5).reverse(),
+    description:          (data.description || '').slice(0, 200),
+    homepage:             latestMeta.homepage || null,
+    changelog:            showChangelog ? (latestMeta.repository?.url || null) : null,
+  };
+}
+
+async function checkPypi(lib, showChangelog) {
+  const installed = installedPython(lib);
+  const data      = await fetchJson(`https://pypi.org/pypi/${encodeURIComponent(lib)}/json`);
+  const info      = data.info || {};
+  const latest    = info.version || null;
+
+  const isDeprecated = (info.classifiers || []).some(c => /deprecated/i.test(c));
+  const desc = info.description || '';
+  const notices = desc.split('\n')
+    .filter(l => /deprecated|removed|use.*instead/i.test(l))
+    .slice(0, 5).map(l => l.trim());
+
+  return {
+    lib, registry: 'pypi',
+    installed_version:    installed,
+    latest_version:       latest,
+    up_to_date:           installed === latest,
+    is_deprecated:        isDeprecated,
+    deprecation_notices:  notices,
+    recent_versions:      Object.keys(data.releases || {}).slice(-5).reverse(),
+    requires_python:      info.requires_python || null,
+    description:          (info.summary || '').slice(0, 200),
+    changelog:            showChangelog ? (info.project_urls?.Changelog || null) : null,
+  };
+}
+
+async function checkCrates(lib, showChangelog) {
+  const cwd       = process.cwd();
+  const installed = installedRust(lib, cwd);
+  const data      = await fetchJson(`https://crates.io/api/v1/crates/${encodeURIComponent(lib)}`);
+  const crate     = data.crate || {};
+  const versions  = (data.versions || []).slice(0, 10);
+
+  const yanked = versions.filter(v => v.yanked).map(v => ({ version: v.num }));
+  const recent = versions.slice(0, 5).map(v => ({
+    version: v.num, yanked: v.yanked, date: v.created_at?.slice(0, 10),
+  }));
+
+  return {
+    lib, registry: 'crates.io',
+    installed_version: installed,
+    latest_version:    crate.newest_version || null,
+    up_to_date:        installed === crate.newest_version,
+    yanked_versions:   yanked,
+    recent_versions:   recent,
+    description:       (crate.description || '').slice(0, 200),
+    repository:        crate.repository || null,
+    changelog:         showChangelog ? crate.repository : null,
+  };
+}
+
+async function run(args) {
+  if (args.length === 0 || args[0] === '--help') { console.log(HELP); return; }
+
+  const lib          = args[0];
+  const langArg      = (args.find(a => a.startsWith('--lang=')) || '').replace('--lang=', '') || null;
+  const showChangelog = args.includes('--show-changelog');
+  const lang         = langArg || detectLang(process.cwd());
+
+  if (!lang) {
+    return output(fail('Cannot auto-detect project language. Use --lang=node|python|rust'));
+  }
+
+  try {
+    let result;
+    if      (lang === 'node')   result = await checkNpm(lib, showChangelog);
+    else if (lang === 'python') result = await checkPypi(lib, showChangelog);
+    else if (lang === 'rust')   result = await checkCrates(lib, showChangelog);
+    else return output(fail(`Unsupported lang: ${lang}. Use node|python|rust`));
+    output(ok(result));
+  } catch (err) {
+    // If it looks like a network error — use offline fallback instead of failing
+    const isNetworkError = /connection|DNS|timed out|ENOTFOUND|ECONNREFUSED|ETIMEDOUT/i.test(err.message);
+    if (isNetworkError) {
+      const fallback = offlineFallback(lib, lang, process.cwd());
+      output(ok(fallback));
+    } else {
+      output(fail(`Registry error: ${err.message}`));
+    }
+  }
+}
+
+module.exports = { run };