karajan-code 2.5.0 → 2.6.1

package/src/checks/ports.js

@@ -0,0 +1,110 @@
+/**
+ * Port availability checks for services Karajan controls.
+ *
+ *   - SonarQube port (default 9000): the Docker container binds a fixed port,
+ *     so if it's occupied by a non-Karajan process we cannot "move" it; we
+ *     report FAIL with the occupant PID/command to help the user stop the
+ *     conflicting process. Strategy: manual.
+ *
+ *   - HU Board port (default 4000): an in-process Node server we can rebind
+ *     to any free port in runtime overrides. Strategy: auto.
+ */
+
+import { isPortAvailable, findAvailablePort } from "../utils/port-check.js";
+import { getPortOccupant } from "../utils/port-occupant.js";
+import { STRATEGY } from "./types.js";
+
+const DEFAULT_SONAR_PORT = 9000;
+const DEFAULT_HU_BOARD_PORT = 4000;
+
+function extractPortFromHost(host, fallback) {
+  const m = String(host || "").match(/:(\d+)(?:\/|$)/);
+  return m ? Number(m[1]) : fallback;
+}
+
+/**
+ * Whether the occupant looks like the Karajan-managed Sonar container.
+ * Docker Desktop's proxy is typically `com.docker.backend` / `com.docker.vmnetd`
+ * on macOS and `docker-proxy` on Linux. We treat those as OK.
+ */
+function isKarajanSonarOccupant(occupant) {
+  if (!occupant?.command) return false;
+  const cmd = occupant.command.toLowerCase();
+  return cmd.includes("docker") || cmd.includes("sonar");
+}
+
+export function createSonarPortCheck() {
+  return {
+    name: "port:sonar",
+    label: "SonarQube port",
+    strategy: STRATEGY.MANUAL,
+    applies: (config) => config?.sonarqube?.enabled !== false,
+    async detect({ config }) {
+      const port = extractPortFromHost(config?.sonarqube?.host, DEFAULT_SONAR_PORT);
+      const free = await isPortAvailable(port);
+      if (free) {
+        return { ok: true, severity: "info", detail: `Port ${port} is free (Sonar container not yet running)` };
+      }
+      // Busy — is it our container?
+      const occupant = await getPortOccupant(port);
+      if (occupant && isKarajanSonarOccupant(occupant)) {
+        return {
+          ok: true,
+          severity: "info",
+          detail: `Port ${port} held by Karajan-managed Sonar (${occupant.command} PID ${occupant.pid})`,
+        };
+      }
+      const who = occupant
+        ? `${occupant.command || "unknown"} (PID ${occupant.pid ?? "?"})`
+        : "unknown process";
+      return {
+        ok: false,
+        severity: "fail",
+        detail: `Port ${port} occupied by ${who}`,
+        fix: `Stop the process holding port ${port} or change sonarqube.host in kj.config.yml.`,
+        extra: { port, occupant },
+      };
+    },
+  };
+}
+
+export function createHuBoardPortCheck() {
+  return {
+    name: "port:hu-board",
+    label: "HU Board port",
+    strategy: STRATEGY.AUTO,
+    applies: (config) => config?.hu_board?.enabled !== false,
+    describe: "Rebind HU Board to the next free port",
+    async detect({ config }) {
+      const port = config?.hu_board?.port || DEFAULT_HU_BOARD_PORT;
+      const free = await isPortAvailable(port);
+      if (free) {
+        return { ok: true, severity: "info", detail: `Port ${port} is free` };
+      }
+      const occupant = await getPortOccupant(port);
+      const who = occupant
+        ? `${occupant.command || "unknown"} (PID ${occupant.pid ?? "?"})`
+        : "unknown process";
+      return {
+        ok: false,
+        severity: "warn",
+        detail: `Port ${port} occupied by ${who}`,
+        fix: `Free port ${port} or set hu_board.port in kj.config.yml`,
+        extra: { port, occupant },
+      };
+    },
+    async remediate({ extra }) {
+      const start = (extra?.port ?? DEFAULT_HU_BOARD_PORT) + 1;
+      const found = await findAvailablePort(start, 20);
+      return {
+        fixed: true,
+        detail: `Rebound HU Board to port ${found} (in-memory override)`,
+        changes: { hu_board: { port: found } },
+      };
+    },
+  };
+}
+
+export function getPortChecks() {
+  return [createSonarPortCheck(), createHuBoardPortCheck()];
+}

package/src/checks/rtk.js

@@ -0,0 +1,36 @@
+/**
+ * RTK (Rust Token Killer) availability check. Manual strategy — installation
+ * depends on the host platform and is handled by getInstallCommand().
+ */
+
+import { runCommand } from "../utils/process.js";
+import { getInstallCommand } from "../utils/os-detect.js";
+import { withDocLink } from "../utils/doc-links.js";
+import { STRATEGY } from "./types.js";
+
+export function createRtkCheck() {
+  return {
+    name: "rtk",
+    label: "RTK (Rust Token Killer)",
+    strategy: STRATEGY.MANUAL,
+    async detect() {
+      try {
+        const res = await runCommand("rtk", ["--version"]);
+        if (res.exitCode === 0) {
+          return { ok: true, severity: "info", detail: `${res.stdout.trim()} — token savings active` };
+        }
+      } catch { /* not installed */ }
+      const installCmd = getInstallCommand("rtk");
+      return {
+        ok: false,
+        severity: "warn",
+        detail: "Not found — 60-90% token savings available",
+        fix: withDocLink(`Install: ${installCmd}`, "rtk_install"),
+      };
+    },
+  };
+}
+
+export function getRtkChecks() {
+  return [createRtkCheck()];
+}

package/src/checks/runner.js

@@ -0,0 +1,267 @@
+/**
+ * Check runner. Orchestrates the detect → remediate → re-verify phases for
+ * a list of Check objects.
+ *
+ * Phase 1 (detect): executed in parallel with per-check timeout. Timeouts
+ * are reported as TIMEOUT status (WARN-level), never throw.
+ *
+ * Phase 2 (remediate): sequential, only for failures with strategy auto or
+ * prompt (and user consent for prompt). Skipped entirely when mode is
+ * "check-only". Each remediation has its own timeout (5s default, 60s for
+ * prompted actions like npm install).
+ *
+ * Phase 3 (re-verify): re-runs `detect` once for each check that was
+ * remediated, to confirm the fix actually worked. If re-verify fails, the
+ * status is FAIL (remediation lied).
+ *
+ * Runtime overrides returned by remediations are merged into `runReport.overrides`
+ * for consumers (e.g. preflight → orchestrator) to apply to the active session.
+ */
+
+import { STATUS, STRATEGY } from "./types.js";
+import { withTimeout, TimeoutError } from "../utils/with-timeout.js";
+
+const DEFAULT_DETECT_TIMEOUT_MS = 5000;
+const DEFAULT_REMEDIATE_TIMEOUT_MS = 60000;
+
+/**
+ * @param {import("./types.js").Check[]} checks
+ * @param {{ config: Object }} ctx
+ * @param {{
+ *   mode?: "fix"|"check-only",
+ *   yes?: boolean,
+ *   onConfirm?: (describe: string) => Promise<boolean>,
+ *   timeoutMs?: number,
+ *   remediateTimeoutMs?: number,
+ *   signal?: AbortSignal,
+ *   logger?: { info: Function, warn: Function, error: Function }
+ * }} [options]
+ * @returns {Promise<import("./types.js").RunReport>}
+ */
+export async function runChecks(checks, ctx, options = {}) {
+  const {
+    mode = "fix",
+    yes = false,
+    onConfirm = defaultOnConfirm,
+    timeoutMs = DEFAULT_DETECT_TIMEOUT_MS,
+    remediateTimeoutMs = DEFAULT_REMEDIATE_TIMEOUT_MS,
+    signal,
+    logger = silentLogger(),
+  } = options;
+
+  const { config } = ctx;
+  const startTotal = Date.now();
+  const entries = [];
+  const overrides = {};
+
+  // Build applicable entries (skipped checks noted up front).
+  for (const check of checks) {
+    if (typeof check.applies === "function" && !check.applies(config)) {
+      entries.push({
+        check,
+        status: STATUS.SKIPPED,
+        detail: "Not applicable for current configuration",
+        runMs: 0,
+        detectResult: null,
+        remediated: false,
+      });
+    } else {
+      entries.push({ check, status: null, detail: null, runMs: 0, detectResult: null, remediated: false });
+    }
+  }
+
+  // Phase 1: detect in parallel with timeout.
+  const detectBase = Date.now();
+  await Promise.all(
+    entries.map(async (entry) => {
+      if (entry.status === STATUS.SKIPPED) return;
+      const start = Date.now();
+      try {
+        const result = await withTimeout(entry.check.detect({ config, signal }), timeoutMs, entry.check.name);
+        entry.detectResult = result;
+        entry.runMs = Date.now() - start;
+        entry.status = resolveStatusFromDetect(entry.check, result);
+        entry.detail = result.detail;
+      } catch (err) {
+        entry.runMs = Date.now() - start;
+        if (err instanceof TimeoutError) {
+          entry.detectResult = { ok: false, severity: "warn", detail: `Timeout after ${timeoutMs}ms` };
+          entry.status = STATUS.TIMEOUT;
+          entry.detail = entry.detectResult.detail;
+        } else {
+          entry.detectResult = { ok: false, severity: "fail", detail: `Detection error: ${err.message}` };
+          entry.status = STATUS.FAIL;
+          entry.detail = entry.detectResult.detail;
+        }
+      }
+    })
+  );
+  logger.info?.(`Detect phase done in ${Date.now() - detectBase}ms`);
+
+  // Phase 2: remediate sequentially (only in "fix" mode, only failing checks).
+  if (mode !== "check-only") {
+    for (const entry of entries) {
+      if (!shouldAttemptRemediation(entry)) continue;
+      const { check, detectResult } = entry;
+      if (check.strategy === STRATEGY.PROMPT && !yes) {
+        const approved = await onConfirm(check.describe || `Fix: ${check.name}`);
+        if (!approved) {
+          logger.info?.(`User declined remediation for ${check.name}`);
+          continue;
+        }
+      }
+      const start = Date.now();
+      try {
+        const rem = await withTimeout(
+          check.remediate({ config, extra: detectResult.extra, signal, logger }),
+          remediateTimeoutMs,
+          `${check.name}:remediate`
+        );
+        entry.remediated = rem.fixed === true;
+        entry.runMs += Date.now() - start;
+        if (rem.fixed) {
+          if (rem.changes) mergeOverrides(overrides, rem.changes);
+          entry.detail = rem.detail;
+          entry.status = STATUS.FIXED;
+        } else {
+          entry.detail = rem.detail || entry.detail;
+          entry.status = STATUS.FAIL;
+        }
+      } catch (err) {
+        entry.runMs += Date.now() - start;
+        const msg = err instanceof TimeoutError ? `Remediation timeout after ${remediateTimeoutMs}ms` : `Remediation error: ${err.message}`;
+        entry.detail = msg;
+        entry.status = STATUS.FAIL;
+        logger.warn?.(`Remediation failed for ${check.name}: ${msg}`);
+      }
+    }
+
+    // Phase 3: re-verify fixed checks using the config merged with any
+    // runtime overrides applied by remediations. Without this merge, a check
+    // that rebinds to a new port (override) would re-verify against the old
+    // config and wrongly report failure.
+    const verifyConfig = mergeConfigAndOverrides(config, overrides);
+    await Promise.all(
+      entries.filter((e) => e.remediated).map(async (entry) => {
+        const start = Date.now();
+        try {
+          const result = await withTimeout(entry.check.detect({ config: verifyConfig, signal }), timeoutMs, `${entry.check.name}:reverify`);
+          entry.runMs += Date.now() - start;
+          if (!result.ok) {
+            entry.status = STATUS.FAIL;
+            entry.detail = `${entry.detail} (but re-verify failed: ${result.detail})`;
+          }
+        } catch (err) {
+          entry.runMs += Date.now() - start;
+          entry.status = STATUS.FAIL;
+          entry.detail = `${entry.detail} (re-verify error: ${err.message})`;
+        }
+      })
+    );
+  }
+
+  // Flatten into reports.
+  const reports = entries.map((e) => ({
+    name: e.check.name,
+    label: e.check.label,
+    status: e.status,
+    strategy: e.check.strategy,
+    detail: e.detail ?? "",
+    fix: e.detectResult?.fix,
+    runMs: e.runMs,
+  }));
+
+  const summary = summarize(reports);
+
+  return {
+    checks: reports,
+    overrides,
+    totalMs: Date.now() - startTotal,
+    summary,
+  };
+}
+
+function shouldAttemptRemediation(entry) {
+  if (entry.status === STATUS.SKIPPED) return false;
+  if (entry.status === STATUS.OK) return false;
+  if (entry.status === STATUS.TIMEOUT) return false; // don't remediate when detect itself timed out
+  const { check, detectResult } = entry;
+  if (!check.remediate || !detectResult) return false;
+  if (check.strategy === STRATEGY.MANUAL || check.strategy === STRATEGY.NONE) return false;
+  // Soft failures (WARN) with PROMPT strategy: don't nag the user for optional issues.
+  if (entry.status === STATUS.WARN && check.strategy === STRATEGY.PROMPT) return false;
+  return true;
+}
+
+function resolveStatusFromDetect(check, result) {
+  if (result.ok) return STATUS.OK;
+  const severity = result.severity || "fail";
+  if (severity === "warn") return STATUS.WARN;
+  if (severity === "info") return STATUS.OK; // info is always non-failing
+  if (check.strategy === STRATEGY.NONE) return STATUS.WARN;
+  return STATUS.FAIL;
+}
+
+function summarize(reports) {
+  const summary = { ok: 0, fixed: 0, warn: 0, fail: 0, skipped: 0, timeout: 0 };
+  for (const r of reports) {
+    const k = r.status.toLowerCase();
+    if (k in summary) summary[k]++;
+  }
+  return summary;
+}
+
+/**
+ * Deep-merge (shallow for now, one level deep) remediation changes into overrides.
+ * Remediation outputs like { hu_board: { port: 4007 } } should not overwrite a
+ * sibling key { hu_board: { enabled: true } } that a prior check set.
+ */
+function mergeOverrides(target, source) {
+  for (const [key, value] of Object.entries(source)) {
+    if (value && typeof value === "object" && !Array.isArray(value) && typeof target[key] === "object") {
+      Object.assign(target[key], value);
+    } else {
+      target[key] = value;
+    }
+  }
+}
+
+/**
+ * Produce a shallow-merged copy of config + overrides used during re-verify.
+ * Does not mutate the original config.
+ */
+function mergeConfigAndOverrides(config, overrides) {
+  if (!overrides || Object.keys(overrides).length === 0) return config;
+  const merged = { ...config };
+  for (const [key, value] of Object.entries(overrides)) {
+    if (value && typeof value === "object" && !Array.isArray(value) && typeof config[key] === "object") {
+      merged[key] = { ...config[key], ...value };
+    } else {
+      merged[key] = value;
+    }
+  }
+  return merged;
+}
+
+function defaultOnConfirm() {
+  // Non-interactive by default: refuse prompts unless the caller supplies a real handler.
+  return Promise.resolve(false);
+}
+
+function silentLogger() {
+  return { info() {}, warn() {}, error() {} };
+}
+
+/**
+ * Flatten a RunReport into the legacy doctor.js shape.
+ * OK/FIXED/SKIPPED → ok:true. WARN/FAIL/TIMEOUT → ok:false.
+ */
+export function toLegacyShape(runReport) {
+  return runReport.checks.map((c) => ({
+    name: c.name,
+    label: c.label,
+    ok: c.status === STATUS.OK || c.status === STATUS.FIXED || c.status === STATUS.SKIPPED,
+    detail: c.detail,
+    fix: c.fix ?? null,
+  }));
+}

package/src/checks/skills.js

@@ -0,0 +1,49 @@
+/**
+ * OpenSkills CLI availability check. Only runs when skills are enabled.
+ * Strategy: prompt — we can offer to run `npm install -g openskills`,
+ * but global installs are invasive enough that they need user consent.
+ */
+
+import { isOpenSkillsAvailable } from "../skills/openskills-client.js";
+import { runCommand } from "../utils/process.js";
+import { STRATEGY } from "./types.js";
+
+export function skillsEnabled(config) {
+  return config?.skills?.enabled !== false;
+}
+
+export function createOpenSkillsCheck() {
+  return {
+    name: "openskills",
+    label: "OpenSkills CLI",
+    strategy: STRATEGY.PROMPT,
+    applies: skillsEnabled,
+    describe: "Install OpenSkills globally: npm install -g openskills",
+    async detect() {
+      const available = await isOpenSkillsAvailable();
+      if (available) {
+        return { ok: true, severity: "info", detail: "Available via `npx openskills`" };
+      }
+      return {
+        ok: false,
+        severity: "warn", // skills enabled but missing → degrade gracefully
+        detail: "`npx openskills` not available — skill injection will be skipped",
+        fix: "Install OpenSkills: npm install -g openskills",
+      };
+    },
+    async remediate() {
+      const res = await runCommand("npm", ["install", "-g", "openskills"], { timeout: 60000 });
+      if (res.exitCode === 0) {
+        return { fixed: true, detail: "Installed openskills globally via npm" };
+      }
+      return {
+        fixed: false,
+        detail: `npm install -g openskills failed (exit ${res.exitCode}): ${res.stderr.split("\n")[0]}`,
+      };
+    },
+  };
+}
+
+export function getSkillsChecks() {
+  return [createOpenSkillsCheck()];
+}

package/src/checks/sonar.js

@@ -0,0 +1,67 @@
+/**
+ * SonarQube reachability + auth checks.
+ *
+ * Auto-remediation strategy (preserving existing behavior from
+ * preflight-checks.js): if Sonar is not reachable, try `sonarUp()` which
+ * starts the Docker container, then poll for readiness. If auth fails but
+ * admin credentials exist, generate a fresh token and persist it.
+ */
+
+import { isSonarReachable } from "../sonar/manager.js";
+import { STRATEGY } from "./types.js";
+import { withDocLink } from "../utils/doc-links.js";
+
+/**
+ * Whether Sonar is enabled in the active config.
+ */
+function sonarEnabled(config) {
+  return config.sonarqube?.enabled !== false;
+}
+
+function sonarHost(config) {
+  return config.sonarqube?.host || "http://localhost:9000";
+}
+
+/**
+ * Informative check: Sonar enabled/disabled status.
+ * Produces an OK result with disabled description when Sonar is off.
+ */
+export function createSonarStatusCheck() {
+  return {
+    name: "sonarqube",
+    label: "SonarQube",
+    strategy: STRATEGY.NONE,
+    async detect({ config }) {
+      const host = sonarHost(config);
+      if (!sonarEnabled(config)) {
+        return { ok: true, severity: "info", detail: "Disabled in config" };
+      }
+      let reachable = false;
+      try {
+        reachable = await isSonarReachable(host);
+      } catch {
+        reachable = false;
+      }
+      return {
+        ok: reachable,
+        severity: "fail",
+        detail: reachable ? `Reachable at ${host}` : `Not reachable at ${host}`,
+        fix: reachable
+          ? undefined
+          : withDocLink(
+              "Run 'kj sonar start' or 'docker start karajan-sonarqube'. Use --no-sonar to skip.",
+              "sonar_docker"
+            ),
+        extra: { host, reachable },
+      };
+    },
+  };
+}
+
+/**
+ * All Sonar-related checks. Keeps just the status check for commit 1;
+ * auth + auto-remediation are layered in commit 3.
+ */
+export function getSonarChecks() {
+  return [createSonarStatusCheck()];
+}

package/src/checks/system.js

@@ -0,0 +1,53 @@
+/**
+ * Miscellaneous system-level checks: Karajan version, git repo presence.
+ * Kept in a dedicated module so they're easy to find and extend.
+ */
+
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import { ensureGitRepo } from "../utils/git.js";
+import { STRATEGY } from "./types.js";
+
+function getPackageVersion() {
+  const pkgPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../package.json");
+  return JSON.parse(readFileSync(pkgPath, "utf8")).version;
+}
+
+export function createKarajanVersionCheck() {
+  return {
+    name: "karajan",
+    label: "Karajan Code",
+    strategy: STRATEGY.NONE,
+    async detect() {
+      const version = getPackageVersion();
+      return { ok: true, severity: "info", detail: `v${version}` };
+    },
+  };
+}
+
+export function createGitRepoCheck() {
+  return {
+    name: "git",
+    label: "Git repository",
+    strategy: STRATEGY.MANUAL,
+    async detect() {
+      let gitOk = false;
+      try {
+        gitOk = await ensureGitRepo();
+      } catch {
+        gitOk = false;
+      }
+      return {
+        ok: gitOk,
+        severity: "fail",
+        detail: gitOk ? "Inside a git repository" : "Not a git repository",
+        fix: gitOk ? undefined : "Run 'git init' or navigate to a git-managed project.",
+      };
+    },
+  };
+}
+
+export function getSystemChecks() {
+  return [createKarajanVersionCheck(), createGitRepoCheck()];
+}

package/src/checks/tokens.js

@@ -0,0 +1,96 @@
+/**
+ * API token availability checks.
+ *
+ * Provider tokens (ANTHROPIC_API_KEY / OPENAI_API_KEY / ...) are LAZY:
+ * we only check them for providers that are actually used by at least one
+ * active role in the current config.
+ *
+ * Strategy:
+ *   - Required providers with no key → FAIL, strategy manual (we can't
+ *     fetch an API key for the user). Fix hint includes the how-to URL.
+ *   - Optional providers (opencode, aider) without key → WARN.
+ *   - GH_TOKEN is checked when git.auto_pr=true, strategy prompt (we can
+ *     launch `gh auth login` with user approval).
+ */
+
+import { checkBinary } from "../utils/agent-detect.js";
+import { getRequiredProviderEnvs, hasEnvVar } from "../utils/provider-env.js";
+import { STRATEGY } from "./types.js";
+
+/**
+ * A single provider env check. One is created per active provider.
+ */
+function createProviderTokenCheck(entry) {
+  return {
+    name: `token:${entry.provider}`,
+    label: `API token: ${entry.provider}`,
+    strategy: STRATEGY.MANUAL,
+    async detect() {
+      const ok = hasEnvVar(entry);
+      if (ok) {
+        return { ok: true, severity: "info", detail: `${entry.envVars[0]} is set` };
+      }
+      return {
+        ok: false,
+        severity: entry.optional ? "warn" : "fail",
+        detail: `${entry.envVars.join(" / ")} not set`,
+        fix: `Get an API key at ${entry.howToGetUrl} and export ${entry.envVars[0]}=...`,
+        extra: { provider: entry.provider, envVars: entry.envVars, howToGetUrl: entry.howToGetUrl },
+      };
+    },
+  };
+}
+
+/**
+ * GH token check + auto-remediation via `gh auth login` when it's installed.
+ */
+function createGhTokenCheck() {
+  return {
+    name: "token:gh",
+    label: "GitHub token (for auto_pr)",
+    strategy: STRATEGY.PROMPT,
+    applies: (config) => config?.git?.auto_pr === true,
+    describe: "Run 'gh auth login' to authenticate with GitHub",
+    async detect() {
+      const envOk = !!process.env.GH_TOKEN || !!process.env.GITHUB_TOKEN;
+      if (envOk) {
+        return { ok: true, severity: "info", detail: "GH_TOKEN or GITHUB_TOKEN is set" };
+      }
+      // If `gh` is installed and authenticated, it manages its own token.
+      const gh = await checkBinary("gh");
+      if (!gh.ok) {
+        return {
+          ok: false,
+          severity: "fail",
+          detail: "No GH_TOKEN/GITHUB_TOKEN and `gh` CLI not installed",
+          fix: "Install GitHub CLI (https://cli.github.com) or export GH_TOKEN=...",
+          extra: { hasGh: false },
+        };
+      }
+      return {
+        ok: false,
+        severity: "fail",
+        detail: "No GH_TOKEN/GITHUB_TOKEN; `gh` is installed but auth status unknown",
+        fix: "Run 'gh auth login' or export GH_TOKEN=...",
+        extra: { hasGh: true },
+      };
+    },
+    // remediate() intentionally omitted: launching `gh auth login` requires an
+    // interactive terminal session. The runner's prompt strategy will point
+    // the user to the command and exit with FAIL in non-TTY contexts.
+  };
+}
+
+/**
+ * Build the list of token checks for the active config. Each active provider
+ * gets one, plus conditional GH token when auto_pr is on.
+ *
+ * @param {Object} config
+ * @returns {import("./types.js").Check[]}
+ */
+export function getTokenChecks(config) {
+  const required = getRequiredProviderEnvs(config);
+  const checks = required.map(createProviderTokenCheck);
+  checks.push(createGhTokenCheck());
+  return checks;
+}