sweepi 0.0.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jenna Smith (@jjenzz)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,32 @@
+# sweepi
+
+Run Sweepit lint rules against a project without changing that project's dependencies.
+
+## Usage
+
+```bash
+npx sweepi <project-dir>
+```
+
+If `~/.sweepi` has not been initialized yet, Sweepi will initialize it first.
+
+## Explicit initialization
+
+```bash
+npx sweepi init
+```
+
+This creates `~/.sweepi`, writes `~/.sweepi/eslint.config.mjs`, and installs:
+
+- `eslint@^9`
+- `eslint-plugin-sweepit@latest`
+
+## How lint runs
+
+Sweepi executes ESLint from the private toolchain directory:
+
+```bash
+~/.sweepi/node_modules/.bin/eslint --config ~/.sweepi/eslint.config.mjs <project-dir>
+```
+
+This keeps project dependencies and lockfiles untouched.

package/dist/chunk-TSXPWQWE.js

@@ -0,0 +1,132 @@
+// src/toolchain.ts
+import * as childProcess from "child_process";
+import * as fs from "fs/promises";
+import * as os from "os";
+import * as path from "path";
+var TOOLCHAIN_DIR_NAME = ".sweepi";
+var TOOLCHAIN_PACKAGE_JSON_NAME = "package.json";
+var TOOLCHAIN_CONFIG_NAME = "eslint.config.mjs";
+var TOOLCHAIN_INSTALL_ARGUMENTS = [
+  "install",
+  "--no-save",
+  "--no-audit",
+  "--no-fund",
+  "eslint@^9.0.0",
+  "eslint-plugin-sweepit@latest"
+];
+var TOOLCHAIN_PACKAGE_JSON_CONTENT = JSON.stringify(
+  {
+    name: "sweepi-toolchain",
+    private: true
+  },
+  null,
+  2
+);
+var TOOLCHAIN_CONFIG_CONTENT = `import sweepitPlugin from 'eslint-plugin-sweepit';
+
+export default [...sweepitPlugin.configs.core, ...sweepitPlugin.configs.react];
+`;
+async function initializeToolchain(options = {}) {
+  const homeDirectory = options.homeDirectory ?? os.homedir();
+  const toolchainDirectory = path.join(homeDirectory, TOOLCHAIN_DIR_NAME);
+  const packageJsonPath = path.join(toolchainDirectory, TOOLCHAIN_PACKAGE_JSON_NAME);
+  const configPath = path.join(toolchainDirectory, TOOLCHAIN_CONFIG_NAME);
+  await fs.mkdir(toolchainDirectory, { recursive: true });
+  await ensureFile(packageJsonPath, TOOLCHAIN_PACKAGE_JSON_CONTENT);
+  await ensureFile(configPath, TOOLCHAIN_CONFIG_CONTENT);
+  const eslintBinaryPath = path.join(toolchainDirectory, "node_modules", ".bin", "eslint");
+  const pluginPackagePath = path.join(
+    toolchainDirectory,
+    "node_modules",
+    "eslint-plugin-sweepit",
+    "package.json"
+  );
+  const eslintInstalled = await pathExists(eslintBinaryPath);
+  const pluginInstalled = await pathExists(pluginPackagePath);
+  const installRequired = !eslintInstalled || !pluginInstalled;
+  if (installRequired) {
+    const runInstallCommand = options.runInstallCommand ?? runInstallCommandWithNpm;
+    await runInstallCommand("npm", TOOLCHAIN_INSTALL_ARGUMENTS, toolchainDirectory);
+  }
+  return {
+    toolchainDirectory,
+    installedDependencies: installRequired
+  };
+}
+async function runSweepi(projectDirectory, options = {}) {
+  const resolvedProjectDirectory = path.resolve(projectDirectory);
+  const projectDirectoryStats = await fs.stat(resolvedProjectDirectory).catch(() => null);
+  if (projectDirectoryStats === null || !projectDirectoryStats.isDirectory()) {
+    throw new Error(`Project directory does not exist: ${resolvedProjectDirectory}`);
+  }
+  const initialization = await initializeToolchain({
+    homeDirectory: options.homeDirectory,
+    runInstallCommand: options.runInstallCommand
+  });
+  const eslintBinaryPath = path.join(
+    initialization.toolchainDirectory,
+    "node_modules",
+    ".bin",
+    "eslint"
+  );
+  const configPath = path.join(initialization.toolchainDirectory, TOOLCHAIN_CONFIG_NAME);
+  const runLintCommand = options.runLintCommand ?? runLintCommandWithExecutable;
+  return runLintCommand(
+    eslintBinaryPath,
+    ["--config", configPath, resolvedProjectDirectory],
+    resolvedProjectDirectory
+  );
+}
+async function ensureFile(filePath, content) {
+  const exists = await pathExists(filePath);
+  if (!exists) {
+    await fs.writeFile(filePath, content, "utf8");
+  }
+}
+async function pathExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runInstallCommandWithNpm(command, args, cwd) {
+  await new Promise((resolve2, reject) => {
+    const child = childProcess.spawn(command, args, {
+      cwd,
+      stdio: "inherit",
+      env: process.env
+    });
+    child.on("error", (error) => {
+      reject(error);
+    });
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve2();
+        return;
+      }
+      reject(new Error(`Failed to initialize Sweepi toolchain (exit code ${String(code)}).`));
+    });
+  });
+}
+async function runLintCommandWithExecutable(command, args, cwd) {
+  return new Promise((resolve2, reject) => {
+    const child = childProcess.spawn(command, args, {
+      cwd,
+      stdio: "inherit",
+      env: process.env
+    });
+    child.on("error", (error) => {
+      reject(error);
+    });
+    child.on("exit", (code) => {
+      resolve2(code ?? 1);
+    });
+  });
+}
+
+export {
+  initializeToolchain,
+  runSweepi
+};

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import {
+  initializeToolchain,
+  runSweepi
+} from "./chunk-TSXPWQWE.js";
+
+// src/cli.ts
+async function run() {
+  const command = process.argv[2];
+  if (command === void 0 || command === "--help" || command === "-h") {
+    printHelp();
+    return;
+  }
+  if (command === "init") {
+    const initialization = await initializeToolchain();
+    if (initialization.installedDependencies) {
+      process.stdout.write(
+        `Initialized Sweepi toolchain in ${initialization.toolchainDirectory}
+`
+      );
+      return;
+    }
+    process.stdout.write(
+      `Sweepi toolchain already initialized in ${initialization.toolchainDirectory}
+`
+    );
+    return;
+  }
+  if (command.startsWith("-")) {
+    throw new Error(`Unknown flag "${command}". Try "sweepi --help".`);
+  }
+  const lintExitCode = await runSweepi(command);
+  process.exitCode = lintExitCode;
+}
+function printHelp() {
+  process.stdout.write(`Usage:
+  sweepi <project-dir>
+  sweepi init
+
+Commands:
+  <project-dir>    Initialize if required, then run eslint using ~/.sweepi
+  init    Create ~/.sweepi and install rules
+`);
+}
+run().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`${message}
+`);
+  process.exitCode = 1;
+});

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+interface InitializeToolchainOptions {
+    homeDirectory?: string;
+    runInstallCommand?: (command: string, args: string[], cwd: string) => Promise<void>;
+}
+interface InitializeToolchainResult {
+    toolchainDirectory: string;
+    installedDependencies: boolean;
+}
+interface RunSweepiOptions {
+    homeDirectory?: string;
+    runInstallCommand?: (command: string, args: string[], cwd: string) => Promise<void>;
+    runLintCommand?: (command: string, args: string[], cwd: string) => Promise<number>;
+}
+declare function initializeToolchain(options?: InitializeToolchainOptions): Promise<InitializeToolchainResult>;
+declare function runSweepi(projectDirectory: string, options?: RunSweepiOptions): Promise<number>;
+
+export { type InitializeToolchainOptions, type InitializeToolchainResult, type RunSweepiOptions, initializeToolchain, runSweepi };

package/dist/index.js

@@ -0,0 +1,8 @@
+import {
+  initializeToolchain,
+  runSweepi
+} from "./chunk-TSXPWQWE.js";
+export {
+  initializeToolchain,
+  runSweepi
+};

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "sweepi",
+  "version": "0.0.5",
+  "description": "Run Sweepit lint rules without modifying project dependencies.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "sweepi": "./dist/cli.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "prepack": "npm run build",
+    "build": "tsup src/index.ts src/cli.ts --format esm --dts --out-dir dist --clean",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@types/node": "^24.3.0",
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.2",
+    "vitest": "^2.1.3"
+  },
+  "gitHead": "046082f22ae7eb53f784ece9379e729e73e2d7e2"
+}