@xylabs/toolchain 7.10.0

package/dist/xy/lint/lint/index.mjs

@@ -0,0 +1,695 @@
+// src/xy/lint/lint/index.ts
+import chalk7 from "chalk";
+
+// src/lib/checkResult.ts
+import chalk from "chalk";
+var checkResult = (name, result, level = "error", exitOnFail = false) => {
+  if (result) {
+    const exiting = exitOnFail ? "[Exiting Process]" : "[Continuing]";
+    const chalkFunc = level === "error" ? chalk.red : chalk.yellow;
+    console[level](chalkFunc(`${name} had ${result} failures ${exiting}`));
+    if (exitOnFail) {
+      process.exit(result);
+    }
+  }
+};
+
+// src/lib/concurrency.ts
+import { AsyncLocalStorage } from "async_hooks";
+var outputStorage = new AsyncLocalStorage();
+var captureInstalled = false;
+function installOutputCapture() {
+  if (captureInstalled) return;
+  captureInstalled = true;
+  const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+  const originalStderrWrite = process.stderr.write.bind(process.stderr);
+  function intercept(original) {
+    return function(chunk, ...args) {
+      const buffer = outputStorage.getStore();
+      if (buffer) {
+        buffer.push(typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk));
+        return true;
+      }
+      return original(chunk, ...args);
+    };
+  }
+  process.stdout.write = intercept(originalStdoutWrite);
+  process.stderr.write = intercept(originalStderrWrite);
+}
+async function runWithConcurrency(items, concurrency, fn) {
+  let next = 0;
+  async function worker() {
+    while (next < items.length) {
+      const i = next++;
+      await fn(items[i]);
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => worker()));
+}
+
+// src/pm/detectPackageManager.ts
+import { existsSync } from "fs";
+function detectPackageManager() {
+  if (existsSync("pnpm-lock.yaml") || existsSync("pnpm-workspace.yaml")) return "pnpm";
+  return "yarn";
+}
+
+// src/pm/registry.ts
+var implementations = /* @__PURE__ */ new Map();
+function getPackageManager(name) {
+  const pmName = name ?? detectPackageManager();
+  const pm = implementations.get(pmName);
+  if (!pm) {
+    throw new Error(
+      `No package manager implementation registered for "${pmName}". Ensure registerPackageManager() has been called before getPackageManager().`
+    );
+  }
+  return pm;
+}
+
+// src/lib/processEx.ts
+import chalk2 from "chalk";
+
+// src/lib/withError.ts
+var withError = (ex, closure, predicate = (ex2) => !!ex2.name && !!ex2.message) => {
+  return predicate(ex) ? closure(ex) : void 0;
+};
+
+// src/lib/withErrnoException.ts
+var withErrnoException = (ex, closure) => {
+  return withError(ex, closure, (ex2) => ex2.errno !== void 0);
+};
+
+// src/lib/processEx.ts
+var processEx = (ex) => {
+  const error = typeof ex === "string" ? new Error(ex) : ex;
+  const exitCode = withErrnoException(error, (error2) => {
+    if (error2.code === "ENOENT") {
+      console.error(chalk2.red(`'${error2.path}' not found.`));
+    } else {
+      console.error(chalk2.red(`Errno: ${error2.code}`));
+    }
+    return error2.errno ?? -1;
+  }) ?? withError(error, (error2) => {
+    console.error(chalk2.red(`${error2.name}: ${error2.message}`));
+    return -1;
+  }) ?? (() => {
+    console.error(chalk2.red(`Unexpected Error: ${JSON.stringify(ex, null, 2)}`));
+    return -1;
+  })();
+  process.exit(process.exitCode ?? exitCode);
+};
+
+// src/lib/safeExit.ts
+var safeExit = (func, exitOnFail = true) => {
+  try {
+    const result = func();
+    if (result && exitOnFail) {
+      process.exit(result);
+    }
+    return result;
+  } catch (ex) {
+    return processEx(ex);
+  }
+};
+
+// src/lib/initCwd.ts
+function INIT_CWD() {
+  return process.env.INIT_CWD ?? process.cwd();
+}
+
+// src/lib/packageName.ts
+import { readFileSync } from "fs";
+import path from "path";
+function packageName() {
+  if (process.env.npm_package_name) {
+    return process.env.npm_package_name;
+  }
+  try {
+    const pkgPath = path.join(INIT_CWD(), "package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+    return pkg.name;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/lib/runInstall.ts
+import { spawnSync } from "child_process";
+import chalk3 from "chalk";
+function runInstall(cwd) {
+  const pm = detectPackageManager();
+  console.log(chalk3.gray(`Running ${pm} install...`));
+  const result = spawnSync(pm, ["install"], {
+    cwd,
+    stdio: "inherit"
+  });
+  if (result.status !== 0) {
+    console.warn(chalk3.yellow(`${pm} install failed`));
+    return false;
+  }
+  console.log(chalk3.green("Dependencies installed"));
+  return true;
+}
+
+// src/lib/runSteps.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import chalk4 from "chalk";
+var runSteps = (name, steps, exitOnFail = true, messages) => {
+  return safeExit(() => {
+    const pkgName = packageName();
+    console.log(chalk4.green(`${name} [${pkgName}]`));
+    let totalStatus = 0;
+    for (const [i, [command, args, config]] of steps.entries()) {
+      if (messages?.[i]) {
+        console.log(chalk4.gray(messages?.[i]));
+      }
+      const argList = Array.isArray(args) ? args : args.split(" ");
+      if (command === "node" && !existsSync2(argList[0])) {
+        throw new Error(`File not found [${argList[0]}]`);
+      }
+      const status = spawnSync2(command, Array.isArray(args) ? args : args.split(" "), {
+        ...config,
+        encoding: "utf8",
+        env: { FORCE_COLOR: "3", ...process.env },
+        shell: true,
+        stdio: "inherit"
+      }).status ?? 0;
+      checkResult(name, status, "error", exitOnFail);
+      totalStatus += status ?? 0;
+    }
+    return totalStatus;
+  }, !!exitOnFail);
+};
+
+// src/actions/lintNext.ts
+import path2 from "path";
+import chalk5 from "chalk";
+import { ESLint } from "eslint";
+var dumpMessages = (lintResults) => {
+  const colors = ["white", "yellow", "red"];
+  const severity = ["none", "warning", "error"];
+  for (const lintResult of lintResults) {
+    if (lintResult.messages.length > 0) {
+      console.log(chalk5.gray(`
+${lintResult.filePath}`));
+      for (const message of lintResult.messages) {
+        console.log(
+          chalk5.gray(`	${message.line}:${message.column}`),
+          chalk5[colors[message.severity]](`	${severity[message.severity]}`),
+          chalk5.white(`	${message.message}`),
+          chalk5.gray(`	${message.ruleId}`)
+        );
+      }
+    }
+  }
+};
+async function lintOnePackage({
+  cache,
+  cwd,
+  fix: fix2,
+  verbose
+}) {
+  const engine = new ESLint({
+    cache,
+    cacheLocation: path2.join(cwd, ".eslintcache"),
+    cacheStrategy: "content",
+    cwd,
+    fix: fix2,
+    warnIgnored: false
+  });
+  const lintResults = await engine.lintFiles(".");
+  dumpMessages(lintResults);
+  if (fix2) {
+    await ESLint.outputFixes(lintResults);
+  }
+  const errors = lintResults.reduce((sum, r) => sum + r.errorCount, 0);
+  const warnings = lintResults.reduce((sum, r) => sum + r.warningCount, 0);
+  const files = lintResults.length;
+  if (verbose) {
+    const filesColor = files < 100 ? "green" : files < 1e3 ? "yellow" : "red";
+    console.log(chalk5.white(`  ${chalk5[filesColor](files)} files linted`));
+  }
+  return {
+    errors,
+    files,
+    warnings
+  };
+}
+async function lintNext({
+  cache = false,
+  fix: fix2 = false,
+  jobs,
+  pkg,
+  verbose = false
+}) {
+  const rootDir = INIT_CWD();
+  const pm = getPackageManager();
+  const allWorkspaces = pm.listWorkspaces();
+  const workspaces = pkg ? allWorkspaces.filter((ws) => ws.name === pkg) : allWorkspaces;
+  if (workspaces.length === 0) {
+    console.log(chalk5.red(pkg ? `Package "${pkg}" not found` : "No workspaces found"));
+    return 1;
+  }
+  const concurrency = jobs;
+  const label = fix2 ? "Fix" : "Lint";
+  installOutputCapture();
+  const results = Array.from(
+    { length: workspaces.length },
+    () => ({
+      errors: 0,
+      files: 0,
+      output: [],
+      pkg: "",
+      timeMs: 0,
+      warnings: 0
+    })
+  );
+  await runWithConcurrency(
+    workspaces.map((ws, i) => ({ i, ws })),
+    concurrency,
+    async ({ i, ws }) => {
+      const output = [];
+      await outputStorage.run(output, async () => {
+        const pkgStart = Date.now();
+        const absCwd = path2.resolve(rootDir, ws.location);
+        console.log(chalk5.green(`${label} [${ws.name}]`));
+        try {
+          const {
+            errors,
+            files,
+            warnings
+          } = await lintOnePackage({
+            cache,
+            cwd: absCwd,
+            fix: fix2,
+            verbose
+          });
+          const timeMs = Date.now() - pkgStart;
+          results[i] = {
+            errors,
+            files,
+            output,
+            pkg: ws.name,
+            timeMs,
+            warnings
+          };
+        } catch (ex) {
+          output.push(chalk5.red(`${label} failed for ${ws.name}: ${ex.message}
+`));
+          results[i] = {
+            errors: 1,
+            files: 0,
+            output,
+            pkg: ws.name,
+            timeMs: Date.now() - pkgStart,
+            warnings: 0
+          };
+        }
+      });
+    }
+  );
+  let totalErrors = 0;
+  let totalWarnings = 0;
+  let totalFiles = 0;
+  for (const result of results) {
+    for (const line of result.output) {
+      process.stdout.write(line);
+    }
+    totalErrors += result.errors;
+    totalWarnings += result.warnings;
+    totalFiles += result.files;
+  }
+  const errColor = totalErrors > 0 ? "red" : "green";
+  const warnColor = totalWarnings > 0 ? "yellow" : "green";
+  console.log(
+    chalk5[errColor](`${totalErrors} errors`) + chalk5.gray(", ") + chalk5[warnColor](`${totalWarnings} warnings`) + chalk5.gray(` across ${totalFiles} files in ${workspaces.length} packages`)
+  );
+  return totalErrors;
+}
+
+// src/actions/lint.ts
+var lintPackage = ({
+  pkg,
+  fix: fix2,
+  verbose
+}) => {
+  const pm = getPackageManager();
+  return runSteps(`${fix2 ? "Fix" : "Lint"} [${pkg}]`, [
+    pm.runInWorkspace(pkg, fix2 ? "package-fix" : verbose ? "package-lint-verbose" : "package-lint")
+  ]);
+};
+var lint = ({
+  cache,
+  fix: fix2,
+  jobs,
+  next,
+  pkg,
+  verbose
+}) => {
+  if (next) {
+    return lintNext({
+      cache,
+      fix: fix2,
+      jobs,
+      pkg,
+      verbose
+    });
+  }
+  return pkg === void 0 ? lintAllPackages({ fix: fix2 }) : lintPackage({
+    pkg,
+    fix: fix2,
+    verbose
+  });
+};
+var lintAllPackages = ({ fix: fix2 = false } = {}) => {
+  const fixOptions = fix2 ? ["--fix"] : [];
+  return runSteps(`${fix2 ? "Fix" : "Lint"} [All-Packages]`, [
+    ["eslint", ["--cache", "--cache-location", ".eslintcache", "--cache-strategy", "content", ...fixOptions]]
+  ]);
+};
+
+// src/actions/fix.ts
+var fix = (params) => {
+  return lint({ ...params, fix: true });
+};
+
+// src/actions/lint-init.ts
+import {
+  existsSync as existsSync3,
+  readFileSync as readFileSync2,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import PATH from "path";
+import { createInterface } from "readline";
+import chalk6 from "chalk";
+import { globSync } from "glob";
+function askConfirmation(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+var DISALLOWED_IMPORTS_XYLABS = [
+  "@xylabs/api",
+  "@xylabs/array",
+  "@xylabs/arraybuffer",
+  "@xylabs/assert",
+  "@xylabs/axios",
+  "@xylabs/base",
+  "@xylabs/bignumber",
+  "@xylabs/buffer",
+  "@xylabs/creatable",
+  "@xylabs/decimal-precision",
+  "@xylabs/delay",
+  "@xylabs/enum",
+  "@xylabs/error",
+  "@xylabs/eth-address",
+  "@xylabs/events",
+  "@xylabs/exists",
+  "@xylabs/forget",
+  "@xylabs/function-name",
+  "@xylabs/hex",
+  "@xylabs/log",
+  "@xylabs/logger",
+  "@xylabs/object",
+  "@xylabs/platform",
+  "@xylabs/profile",
+  "@xylabs/promise",
+  "@xylabs/retry",
+  "@xylabs/set",
+  "@xylabs/static-implements",
+  "@xylabs/storage",
+  "@xylabs/telemetry",
+  "@xylabs/telemetry-exporter",
+  "@xylabs/timer",
+  "@xylabs/typeof",
+  "@xylabs/url",
+  "@xylabs/zod"
+];
+var DISALLOWED_IMPORTS_XYO = [
+  "@xyo-network/core-payload-plugins",
+  "@xyo-network/manifest",
+  "@xyo-network/modules",
+  "@xyo-network/protocol",
+  "@xyo-network/sdk-utils",
+  "@xyo-network/shared",
+  "@xyo-network/manifest-model",
+  "@xyo-network/manifest-wrapper",
+  "@xyo-network/boundwitness",
+  "@xyo-network/core",
+  "@xyo-network/crypto",
+  "@xyo-network/payload",
+  "@xyo-network/api",
+  "@xyo-network/api-models",
+  "@xyo-network/dns",
+  "@xyo-network/metamask-connector",
+  "@xyo-network/module-factory-locator",
+  "@xyo-network/schema-payload-plugin",
+  "@xyo-network/archivist-memory",
+  "@xyo-network/id-payload-plugin",
+  "@xyo-network/wallet",
+  "@xyo-network/network",
+  "@xyo-network/payload-plugin",
+  "@xyo-network/payloadset-plugin",
+  "@xyo-network/quadkey",
+  "@xyo-network/schema-cache",
+  "@xyo-network/schema-name-validator",
+  "@xyo-network/witnesses"
+];
+function getRequiredDevDependencies(react) {
+  const configPkg = react ? "@xylabs/eslint-config-react-flat" : "@xylabs/eslint-config-flat";
+  return {
+    [configPkg]: "workspace:^",
+    eslint: "^10.0.0"
+  };
+}
+function formatDisallowedArray(name, imports) {
+  const items = imports.map((i) => `  '${i}',`).join("\n");
+  return `const ${name} = [
+${items}
+]`;
+}
+function generateEslintConfig({
+  react,
+  useXyLabsBarrel,
+  useXyoBarrel
+}) {
+  const configPkg = react ? "@xylabs/eslint-config-react-flat" : "@xylabs/eslint-config-flat";
+  const lines = [
+    "import type { Linter } from 'eslint'",
+    "",
+    `import { config as xylabsConfig } from '${configPkg}'`,
+    ""
+  ];
+  if (useXyLabsBarrel) {
+    lines.push(formatDisallowedArray("disallowedImportsXyLabs", DISALLOWED_IMPORTS_XYLABS), "");
+  }
+  if (useXyoBarrel) {
+    lines.push(formatDisallowedArray("disallowedImportsXyo", DISALLOWED_IMPORTS_XYO), "");
+  }
+  lines.push("const config: Linter.Config[] = [", "  { ignores: ['.yarn/**', 'build', '**/build/**', '**/dist/**', 'dist', 'node_modules/**', '**/node_modules/**', '**/*.md/**', '.claude/worktrees/*'] },", "  ...xylabsConfig,");
+  if (useXyLabsBarrel || useXyoBarrel) {
+    lines.push("  {", "    rules:", "    {", "      'no-restricted-imports': [", "        'warn',", "        {");
+    if (useXyLabsBarrel && useXyoBarrel) {
+      lines.push("          paths: [", "            ...disallowedImportsXyLabs,", "            ...disallowedImportsXyo,", "          ],");
+    } else if (useXyLabsBarrel) {
+      lines.push("          paths: [", "            ...disallowedImportsXyLabs,", "          ],");
+    } else {
+      lines.push("          paths: [", "            ...disallowedImportsXyo,", "          ],");
+    }
+    lines.push("        },", "      ],", "    },", "  },");
+  }
+  lines.push("]", "", "export default config", "");
+  return lines.join("\n");
+}
+function addDevDependencies(packageJsonPath, requiredDeps, verbose) {
+  const content = readFileSync2(packageJsonPath, "utf8");
+  const pkg = JSON.parse(content);
+  const devDeps = pkg.devDependencies ?? {};
+  let changed = false;
+  for (const [name, version] of Object.entries(requiredDeps)) {
+    if (!devDeps[name]) {
+      devDeps[name] = version;
+      changed = true;
+      if (verbose) console.log(chalk6.gray(`  Added ${name}@${version} to devDependencies`));
+    } else if (verbose) {
+      console.log(chalk6.gray(`  ${name} already in devDependencies`));
+    }
+  }
+  if (changed) {
+    const sorted = Object.fromEntries(Object.entries(devDeps).toSorted(([a], [b]) => a.localeCompare(b)));
+    pkg.devDependencies = sorted;
+    writeFileSync(packageJsonPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+    console.log(chalk6.green("Updated package.json devDependencies"));
+  } else {
+    console.log(chalk6.gray("package.json devDependencies already up to date"));
+  }
+  return changed;
+}
+function detectReactInMonorepo(cwd, verbose) {
+  const packageJsonPaths = globSync("packages/**/package.json", {
+    cwd,
+    ignore: ["**/node_modules/**"]
+  });
+  for (const relPath of packageJsonPaths) {
+    const fullPath = PATH.resolve(cwd, relPath);
+    try {
+      const content = readFileSync2(fullPath, "utf8");
+      const pkg = JSON.parse(content);
+      const deps = pkg.dependencies;
+      const peerDeps = pkg.peerDependencies;
+      if (deps?.react || peerDeps?.react) {
+        if (verbose) console.log(chalk6.gray(`  React detected in ${relPath}`));
+        return true;
+      }
+    } catch {
+    }
+  }
+  return false;
+}
+function findExistingConfig(configPath, legacyConfigPath) {
+  if (existsSync3(configPath)) return configPath;
+  if (existsSync3(legacyConfigPath)) return legacyConfigPath;
+  return void 0;
+}
+function removeLegacyConfig(legacyConfigPath) {
+  if (existsSync3(legacyConfigPath)) {
+    unlinkSync(legacyConfigPath);
+    console.log(chalk6.gray("Removed legacy eslint.config.mjs"));
+  }
+}
+function updateDependencies(packageJsonPath, react, cwd, verbose) {
+  if (!existsSync3(packageJsonPath)) {
+    console.log(chalk6.yellow("No package.json found \u2014 skipping dependency updates"));
+    return;
+  }
+  const changed = addDevDependencies(packageJsonPath, getRequiredDevDependencies(react), verbose);
+  if (changed) {
+    runInstall(cwd);
+  }
+}
+async function lintInit({ verbose } = {}) {
+  const cwd = INIT_CWD();
+  const configPath = PATH.resolve(cwd, "eslint.config.ts");
+  const legacyConfigPath = PATH.resolve(cwd, "eslint.config.mjs");
+  const existingPath = findExistingConfig(configPath, legacyConfigPath);
+  if (existingPath) {
+    const filename = PATH.basename(existingPath);
+    const confirmed = await askConfirmation(
+      chalk6.yellow(`${filename} already exists. Replace it with eslint.config.ts? (y/N) `)
+    );
+    if (!confirmed) {
+      console.log(chalk6.gray(`Skipped \u2014 existing ${filename} preserved`));
+      return 0;
+    }
+  }
+  const react = detectReactInMonorepo(cwd, verbose);
+  if (react) {
+    console.log(chalk6.cyan("Detected React packages \u2014 using @xylabs/eslint-config-react-flat"));
+  } else if (verbose) {
+    console.log(chalk6.gray("  No React packages detected \u2014 using @xylabs/eslint-config-flat"));
+  }
+  const useXyLabsBarrel = await askConfirmation(
+    chalk6.cyan("Disallow @xylabs/sdk-js barrel imports? (y/N) ")
+  );
+  const useXyoBarrel = await askConfirmation(
+    chalk6.cyan("Disallow @xyo-network/sdk-js barrel imports? (y/N) ")
+  );
+  const config = generateEslintConfig({
+    react,
+    useXyLabsBarrel,
+    useXyoBarrel
+  });
+  writeFileSync(configPath, config, "utf8");
+  console.log(chalk6.green("Generated eslint.config.ts"));
+  removeLegacyConfig(legacyConfigPath);
+  updateDependencies(PATH.resolve(cwd, "package.json"), react, cwd, verbose);
+  return 0;
+}
+
+// src/xy/lint/lint/initCommand.ts
+var initCommand = {
+  command: "init",
+  describe: "Generate eslint.config.ts and add ESLint dependencies",
+  handler: async (argv) => {
+    if (argv.verbose) console.log("Lint Init");
+    process.exitCode = await lintInit({ verbose: !!argv.verbose });
+  }
+};
+
+// src/xy/param.ts
+var packagePositionalParam = (yargs) => {
+  return yargs.positional("package", { describe: "Specific package to target", type: "string" });
+};
+
+// src/xy/lint/lint/runCommand.ts
+var runCommand = {
+  aliases: ["$0"],
+  builder: (yargs) => {
+    return packagePositionalParam(yargs).option("fix", {
+      alias: "f",
+      default: false,
+      description: "Fix fixable issues",
+      type: "boolean"
+    }).option("cache", {
+      alias: "c",
+      default: false,
+      description: "Use caching for performance",
+      type: "boolean"
+    }).option("next", {
+      alias: "n",
+      default: false,
+      description: "Lint per-package (lower memory, parallel)",
+      type: "boolean"
+    });
+  },
+  command: "run [package]",
+  describe: "Run ESLint",
+  handler: async (argv) => {
+    if (argv.verbose) console.log("Lint");
+    process.exitCode = argv.fix ? await fix({
+      cache: argv.cache,
+      jobs: argv.jobs,
+      next: argv.next,
+      pkg: argv.package,
+      verbose: !!argv.verbose
+    }) : await lint({
+      cache: argv.cache,
+      jobs: argv.jobs,
+      next: argv.next,
+      pkg: argv.package,
+      verbose: !!argv.verbose
+    });
+  }
+};
+
+// src/xy/lint/lint/index.ts
+var lintCommand = {
+  builder: (yargs) => {
+    return yargs.command(runCommand).command(initCommand).option("init", {
+      default: false,
+      description: "Generate eslint.config.ts and add ESLint dependencies",
+      hidden: true,
+      type: "boolean"
+    });
+  },
+  command: "lint",
+  describe: "Lint - Run ESLint",
+  handler: async (argv) => {
+    if (argv.init) {
+      console.warn(chalk7.yellow('Deprecated: use "xy lint init" instead of "xy lint --init"'));
+      process.exitCode = await lintInit({ verbose: !!argv.verbose });
+    }
+  }
+};
+export {
+  lintCommand
+};
+//# sourceMappingURL=index.mjs.map