fchek 1.0.0

package/README.md

@@ -0,0 +1,64 @@
+# fchek — Developer & AI Autonomous Toolbox
+
+`fchek` is a command-line toolbox designed for developers and AI agents to run code, verify tests, check network ports, query databases, audit container health, profile performance, and manage codebases efficiently.
+
+---
+
+## Installation
+
+```bash
+npm install -g .
+```
+
+Verify with:
+```bash
+fchek --help
+```
+
+---
+
+## All Commands
+
+### Full Automation
+* `fchek audit [dir]` — Full audit: context + secrets + lint + test + deps in one run.
+* `fchek test [dir]` — Auto-detect test framework (pytest, jest, vitest, mocha, cargo, go, dotnet) and run tests.
+* `fchek git <action>` — Safe git operations (status, diff, stage, commit, etc.).
+* `fchek config [action]` — Read or write `.fchekrc` config.
+
+### Code Intelligence (Before Code)
+* `fchek context <dir>` — Dump all symbols to avoid duplicates.
+* `fchek convention <dir>` — Analyze coding patterns (style, error handling, logging).
+* `fchek deps-check <lib>` — Live API registry checking.
+
+### Execute & Verify (After Code)
+* `fchek run <file>` — Execute file and get structured JSON stdout/stderr/exit_code.
+* `fchek secrets <path>` — Scan for credentials (gitleaks, trufflehog, or regex).
+* `fchek vuln [dir]` — Scan dependencies for vulnerabilities and typosquatting.
+* `fchek dom <url|file> <selector>` — Query HTML page elements using CSS selectors.
+
+### Network & Databases
+* `fchek port <port> [--all]` — Network port inspector (checks if a port is in use and returns the process PID & name).
+* `fchek api <url> [options]` — HTTP API tester with status codes, headers, and timing metrics.
+* `fchek db <action> <db_path> [sql]` — SQLite schema inspector (`schema`) and query runner (`query`).
+* `fchek docker <action> [options]` — Docker assistant: lists containers (`list`) or gets logs (`logs`).
+
+### Windows Integration
+* `fchek screenshot [--window=<title>]` — Screenshot window or desktop.
+* `fchek launch <exe>` — Launch application and wait for window creation.
+* `fchek winlog` — Get Windows event logs.
+* `fchek registry <action>` — Query or modify Windows Registry.
+* `fchek process <action>` — Manage processes.
+* `fchek watch <dir>` — Watch directory, rebuild, and relaunch on modification.
+
+### Analysis & Memory
+* `fchek profile <file>` — Hot path profiling.
+* `fchek coverage <dir>` — Code coverage reports.
+* `fchek bench --before --after` — Benchmark code speedups.
+* `fchek lint <dir>` — Code format and linter with auto-fixing.
+* `fchek deps <dir>` — Identify dead code/circular dependencies.
+* `fchek race <file>` — ThreadSanitizer/AddressSanitizer checks.
+* `fchek fuzz <file>` — AFL++/cargo-fuzz runner.
+* `fchek goto <file:line>` — Navigation & references.
+* `fchek state <action>` — Persistent project memory.
+* `fchek repl` — Interactive REPL with session variables.
+* `fchek doctor` — Verify local environment & dependencies.

package/bin/fchek.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const COMMANDS = {
+  context:      () => require('../lib/context'),
+  convention:   () => require('../lib/convention'),
+  'deps-check': () => require('../lib/deps-check'),
+  run:          () => require('../lib/run'),
+  test:         () => require('../lib/test'),
+  secrets:      () => require('../lib/secrets'),
+  audit:        () => require('../lib/audit'),
+  git:          () => require('../lib/git'),
+  config:       () => require('../lib/config'),
+  screenshot:   () => require('../lib/screenshot'),
+  launch:       () => require('../lib/launch'),
+  winlog:       () => require('../lib/winlog'),
+  registry:     () => require('../lib/registry'),
+  process:      () => require('../lib/process'),
+  watch:        () => require('../lib/watch'),
+  profile:      () => require('../lib/profile'),
+  coverage:     () => require('../lib/coverage'),
+  bench:        () => require('../lib/bench'),
+  lint:         () => require('../lib/lint'),
+  deps:         () => require('../lib/deps'),
+  race:         () => require('../lib/race'),
+  fuzz:         () => require('../lib/fuzz'),
+  goto:         () => require('../lib/goto'),
+  state:        () => require('../lib/state'),
+  repl:         () => require('../lib/repl'),
+  doctor:       () => require('../lib/doctor'),
+  port:         () => require('../lib/port'),
+  api:          () => require('../lib/api'),
+  db:           () => require('../lib/db'),
+  docker:       () => require('../lib/docker'),
+  vuln:         () => require('../lib/vuln'),
+  dom:          () => require('../lib/dom'),
+};
+
+const HELP = `
+fchek — developer & AI autonomous toolbox
+
+── Full Automation ──────────────────────────────────────────────────────
+  audit    [dir] [--quick]         Full audit in one command
+  test     [dir] [--filter=<n>]    Auto-detect & run tests
+  git      <action>                status/diff/log/stage/commit
+  config   [action]                Read/write .fchekrc
+
+── Code Intelligence (BEFORE code) ─────────────────────────────────────
+  context    <dir>                 All symbols — avoid duplicates
+  convention <dir>                 Coding patterns (style, errors, logging)
+  deps-check <lib>                 Live API check from registry
+
+── Execute & Verify (AFTER code) ───────────────────────────────────────
+  run      <file>                  Run → stdout/stderr/exit_code
+  secrets  <path>                  Scan for credentials
+  vuln     [dir]                   Scan for typosquatting & vulnerabilities
+  dom      <url|file> <sel>        Query HTML DOM elements
+
+── Windows ─────────────────────────────────────────────────────────────
+  screenshot [--window=<title>]    Capture window/screen → PNG
+  launch   <exe> [--wait=ms]       Launch app, wait for window
+  winlog   [--filter=<app>]        Event Viewer logs
+  registry <action> <key>          Read/write registry
+  process  <action> [name|pid]     List/kill/info processes
+  watch    <dir> [--cmd=<build>]   Auto-rebuild on file change
+
+── Network & Databases ─────────────────────────────────────────────────
+  port     <port> [--all]          Network port scanner & connection info
+  api      <url> [options]         API / HTTP query tester
+  db       <action> <db> [sql]     SQLite schema & query runner
+  docker   <action> [options]      Docker ps and logs helper
+
+── Analysis ────────────────────────────────────────────────────────────
+  profile / coverage / bench / lint / deps / race / fuzz / goto
+
+── Memory & Environment ────────────────────────────────────────────────
+  state / repl / doctor
+
+Output: JSON { "status": "ok"|"error", "data":{...} }
+`.trim();
+
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+    console.log(HELP); process.exit(0);
+  }
+
+  const cmd = args[0];
+  const cmdArgs = args.slice(1);
+
+  if (!COMMANDS[cmd]) {
+    console.error(`\nError: unknown command "${cmd}"\n`);
+    console.log(HELP); process.exit(1);
+  }
+
+  try {
+    await COMMANDS[cmd]().run(cmdArgs);
+  } catch (err) {
+    const { output, fail } = require('../lib/output');
+    output(fail(err.message, cmd));
+    if (process.env.DEBUG) console.error(err.stack);
+    process.exit(1);
+  }
+}
+
+main();

package/lib/api.js

@@ -0,0 +1,110 @@
+'use strict';
+
+const http = require('http');
+const https = require('https');
+const { URL } = require('url');
+const { output, ok, fail } = require('./output');
+
+const HELP = `
+fchek api <url> [--method=<method>] [--headers=<key:val,key2:val2>] [--body=<body>]
+
+Test API endpoints and HTTP services.
+Returns response status, headers, body size, and roundtrip latency.
+`.trim();
+
+function run(args) {
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(HELP);
+    return Promise.resolve();
+  }
+
+  const urlStr = args.find(a => !a.startsWith('-'));
+  if (!urlStr) {
+    output(fail('Please specify a URL (e.g. fchek api https://api.github.com)', 'api'));
+    return Promise.resolve();
+  }
+
+  let method = 'GET';
+  let headers = {};
+  let body = '';
+
+  for (const arg of args) {
+    if (arg.startsWith('--method=')) {
+      method = arg.split('=')[1].toUpperCase();
+    } else if (arg.startsWith('--headers=')) {
+      const headersStr = arg.slice(10);
+      const items = headersStr.split(',');
+      for (const item of items) {
+        const colonIdx = item.indexOf(':');
+        if (colonIdx !== -1) {
+          const k = item.slice(0, colonIdx).trim();
+          const v = item.slice(colonIdx + 1).trim();
+          headers[k] = v;
+        }
+      }
+    } else if (arg.startsWith('--body=')) {
+      body = arg.slice(7);
+    }
+  }
+
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(urlStr);
+  } catch (err) {
+    output(fail(`Invalid URL: ${err.message}`, 'api'));
+    return Promise.resolve();
+  }
+
+  const protocol = parsedUrl.protocol === 'https:' ? https : http;
+  const options = {
+    method,
+    headers,
+    timeout: 10000,
+  };
+
+  const startTime = process.hrtime();
+
+  return new Promise((resolve) => {
+    const req = protocol.request(urlStr, options, (res) => {
+      let responseData = '';
+      res.setEncoding('utf8');
+      res.on('data', (chunk) => {
+        responseData += chunk;
+      });
+
+      res.on('end', () => {
+        const diff = process.hrtime(startTime);
+        const timeMs = Math.round(diff[0] * 1000 + diff[1] / 1000000);
+
+        output(ok({
+          status_code: res.statusCode,
+          status_text: res.statusMessage || '',
+          time_ms: timeMs,
+          headers: res.headers,
+          body_size_bytes: Buffer.byteLength(responseData, 'utf8'),
+          body: responseData.slice(0, 10000), // Cap body output to avoid massive JSONs
+          body_truncated: responseData.length > 10000,
+        }, 'api'));
+        resolve();
+      });
+    });
+
+    req.on('error', (err) => {
+      output(fail(`Request failed: ${err.message}`, 'api'));
+      resolve();
+    });
+
+    req.on('timeout', () => {
+      req.destroy();
+      output(fail('Request timed out after 10s', 'api'));
+      resolve();
+    });
+
+    if (body) {
+      req.write(body);
+    }
+    req.end();
+  });
+}
+
+module.exports = { run };

package/lib/audit.js

@@ -0,0 +1,211 @@
+'use strict';
+
+/**
+ * audit.js — full project audit in one command
+ *
+ * Runs sequentially: context → convention → secrets → lint → test → deps → coverage
+ * Returns consolidated JSON with summary and per-tool results.
+ * Agent uses this at project start to understand the full picture.
+ */
+
+const path = require('path');
+const fs   = require('fs');
+const { output, ok, fail } = require('./output');
+
+const HELP = `
+fchek audit [dir] [--quick] [--fix]
+
+Run a full project audit: context, convention, secrets, lint, test, deps, coverage.
+One command instead of six. Use at project start or before a major change.
+
+Options:
+  --quick   Skip slow steps (coverage, fuzz). Faster for CI.
+  --fix     Apply auto-fixes during lint step.
+  --json    Always output JSON (default)
+
+Output: consolidated report with status per tool and overall verdict.
+
+Examples:
+  fchek audit .
+  fchek audit src/ --quick
+  fchek audit . --fix
+`.trim();
+
+async function runStep(name, fn) {
+  const t0 = Date.now();
+  try {
+    // Capture output by temporarily overriding console.log
+    const lines = [];
+    const orig  = console.log;
+    console.log = (s) => lines.push(s);
+    await fn();
+    console.log = orig;
+
+    let data = null;
+    if (lines.length > 0) {
+      try { data = JSON.parse(lines[lines.length - 1]); } catch {}
+    }
+
+    return {
+      step:       name,
+      status:     data?.status ?? 'ok',
+      duration_ms: Date.now() - t0,
+      data:       data?.data ?? null,
+      error:      data?.error ?? null,
+    };
+  } catch (err) {
+    return {
+      step:       name,
+      status:     'error',
+      duration_ms: Date.now() - t0,
+      data:       null,
+      error:      err.message,
+    };
+  }
+}
+
+async function run(args) {
+  if (args[0] === '--help') { console.log(HELP); return; }
+
+  const dir   = args.find(a => !a.startsWith('--')) || '.';
+  const quick = args.includes('--quick');
+  const fix   = args.includes('--fix');
+
+  if (!fs.existsSync(dir)) {
+    return output(fail(`Directory not found: ${dir}`));
+  }
+
+  const absDir = path.resolve(dir);
+  const results = [];
+  const t0Total = Date.now();
+
+  console.error(`[fchek audit] Starting full audit of: ${absDir}`);
+
+  // 1. context — what exists
+  console.error('[fchek audit] 1/7 context...');
+  results.push(await runStep('context', async () => {
+    await require('./context').run([absDir, '--names-only']);
+  }));
+
+  // 2. convention — project patterns
+  console.error('[fchek audit] 2/7 convention...');
+  results.push(await runStep('convention', async () => {
+    await require('./convention').run([absDir]);
+  }));
+
+  // 3. secrets — credentials scan
+  console.error('[fchek audit] 3/7 secrets...');
+  results.push(await runStep('secrets', async () => {
+    await require('./secrets').run([absDir]);
+  }));
+
+  // 4. lint — code quality
+  console.error('[fchek audit] 4/7 lint...');
+  results.push(await runStep('lint', async () => {
+    const lintArgs = [absDir];
+    if (!fix) lintArgs.push('--no-fix');
+    await require('./lint').run(lintArgs);
+  }));
+
+  // 5. test — run tests
+  console.error('[fchek audit] 5/7 test...');
+  results.push(await runStep('test', async () => {
+    await require('./test').run([absDir]);
+  }));
+
+  // 6. deps — dependencies
+  console.error('[fchek audit] 6/7 deps...');
+  results.push(await runStep('deps', async () => {
+    await require('./deps').run([absDir]);
+  }));
+
+  // 7. coverage — only if not quick
+  if (!quick) {
+    console.error('[fchek audit] 7/7 coverage...');
+    results.push(await runStep('coverage', async () => {
+      await require('./coverage').run([absDir]);
+    }));
+  }
+
+  const totalMs = Date.now() - t0Total;
+
+  // Build summary
+  const secretsStep  = results.find(r => r.step === 'secrets');
+  const testStep     = results.find(r => r.step === 'test');
+  const lintStep     = results.find(r => r.step === 'lint');
+  const coverageStep = results.find(r => r.step === 'coverage');
+  const depsStep     = results.find(r => r.step === 'deps');
+
+  const criticalIssues = [];
+
+  if (secretsStep?.data?.verdict && secretsStep.data.verdict !== 'clean') {
+    criticalIssues.push(`SECRETS: ${secretsStep.data.total_findings} findings (${secretsStep.data.verdict})`);
+  }
+  if (testStep?.data?.verdict === 'failures_found') {
+    criticalIssues.push(`TESTS: ${testStep.data.failed} failed`);
+  }
+  if (lintStep?.data?.issues_count > 0) {
+    criticalIssues.push(`LINT: ${lintStep.data.issues_count} issues`);
+  }
+  if (coverageStep?.data?.total_pct !== null && coverageStep?.data?.total_pct < 60) {
+    criticalIssues.push(`COVERAGE: ${coverageStep.data.total_pct}% (below 60%)`);
+  }
+
+  const verdict = criticalIssues.length === 0 ? 'healthy' : 'needs_attention';
+
+  output(ok({
+    dir:          absDir,
+    verdict,
+    critical_issues: criticalIssues,
+    total_ms:     totalMs,
+    quick_mode:   quick,
+    steps:        results.map(r => ({
+      step:       r.step,
+      status:     r.status,
+      duration_ms: r.duration_ms,
+      // Key metrics per step
+      summary: buildStepSummary(r),
+    })),
+    full_results: results,
+    next_actions: buildNextActions(criticalIssues, results),
+  }));
+}
+
+function buildStepSummary(r) {
+  if (!r.data) return r.error ? `error: ${r.error.slice(0, 80)}` : 'no data';
+  const d = r.data;
+  switch (r.step) {
+    case 'context':    return `${d.total_symbols ?? 0} symbols in ${d.total_files ?? 0} files`;
+    case 'convention': return d.summary ?? 'ok';
+    case 'secrets':    return `${d.total_findings ?? 0} findings, verdict: ${d.verdict ?? '?'}`;
+    case 'lint':       return `${d.issues_count ?? 0} issues, build_clean: ${d.build_clean ?? '?'}`;
+    case 'test':       return `${d.passed ?? 0} passed, ${d.failed ?? 0} failed (${d.framework ?? '?'})`;
+    case 'deps':       return `${d.package_count ?? 0} packages, ${d.outdated_count ?? 0} outdated`;
+    case 'coverage':   return `${d.total_pct ?? '?'}% coverage`;
+    default:           return 'ok';
+  }
+}
+
+function buildNextActions(issues, results) {
+  const actions = [];
+  for (const issue of issues) {
+    if (issue.startsWith('SECRETS')) {
+      actions.push('Fix secrets: replace hardcoded values with environment variables');
+    }
+    if (issue.startsWith('TESTS')) {
+      actions.push('Fix failing tests before making any other changes');
+    }
+    if (issue.startsWith('LINT')) {
+      actions.push('Run: fchek lint . --fix  to apply auto-fixes');
+    }
+    if (issue.startsWith('COVERAGE')) {
+      actions.push('Add tests for uncovered code: fchek coverage . to see which lines');
+    }
+  }
+  if (actions.length === 0) {
+    actions.push('Project looks healthy. Proceed with your task.');
+  }
+  return actions;
+}
+
+module.exports = { run };