@lzear/repo-lint 0.0.1

package/dist/bin.js

@@ -0,0 +1,385 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+
+// src/bin.ts
+import { mkdirSync } from "fs";
+import { parseArgs } from "util";
+
+// src/index.ts
+import { execSync } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import { tmpdir } from "os";
+import path2 from "path";
+
+// src/checks.ts
+import { spawnSync } from "child_process";
+import { existsSync, readFileSync, readdirSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { run as ncuRun } from "npm-check-updates";
+import { publint } from "publint";
+var _dirname = path.dirname(fileURLToPath(import.meta.url));
+var readPkg = (dir) => {
+  const f = path.join(dir, "package.json");
+  if (!existsSync(f)) return null;
+  try {
+    return JSON.parse(readFileSync(f, "utf8"));
+  } catch {
+    return null;
+  }
+};
+var getWorkspacePatterns = (pkg) => {
+  const ws = pkg.workspaces;
+  if (Array.isArray(ws)) return ws;
+  const wsPkg = ws;
+  if (Array.isArray(wsPkg?.packages)) return wsPkg.packages;
+  return [];
+};
+var patternToBase = (rootDir, pattern) => {
+  const parts = pattern.split("/");
+  if (parts.length === 2 && parts[1] === "*")
+    return path.join(rootDir, parts[0] ?? "");
+  if (parts.length === 1 && parts[0] === "*") return rootDir;
+  return null;
+};
+var getWorkspaceDirs = (rootDir) => {
+  const pkg = readPkg(rootDir);
+  if (!pkg) return [];
+  const dirs = [];
+  for (const pattern of getWorkspacePatterns(pkg)) {
+    const base = patternToBase(rootDir, pattern);
+    if (!base || !existsSync(base)) continue;
+    for (const entry of readdirSync(base, { withFileTypes: true })) {
+      if (entry.isDirectory()) dirs.push(path.join(base, entry.name));
+    }
+  }
+  return dirs;
+};
+var findBin = (name, startDir) => {
+  let dir = startDir;
+  while (true) {
+    const bin = path.join(dir, "node_modules", ".bin", name);
+    if (existsSync(bin)) return bin;
+    const parent = path.join(dir, "..");
+    if (parent === dir) return null;
+    dir = parent;
+  }
+};
+var eachPublishedPkg = async (dir, fn) => {
+  const pkg = readPkg(dir);
+  if (!pkg) return { pass: true };
+  if (pkg.private === true) {
+    const wsDirs = getWorkspaceDirs(dir);
+    if (wsDirs.length === 0) return { pass: true };
+    const results = await Promise.all(
+      wsDirs.map((d) => eachPublishedPkg(d, fn))
+    );
+    const failures = results.filter((r) => !r.pass);
+    if (failures.length === 0) return { pass: true };
+    return {
+      pass: false,
+      detail: failures.flatMap((r) => r.detail ? [r.detail] : []).join("\n") || void 0
+    };
+  }
+  return fn(dir);
+};
+var readmeIncludes = (dir, needle) => {
+  const f = path.join(dir, "README.md");
+  return existsSync(f) && readFileSync(f, "utf8").includes(needle);
+};
+var LOCAL_CHECKS = [
+  {
+    id: "readme-exists",
+    desc: "README.md exists",
+    type: "local",
+    check: (dir) => existsSync(path.join(dir, "README.md"))
+  },
+  {
+    id: "readme-ci-badge",
+    desc: "README has CI badge",
+    type: "local",
+    check: (dir) => readmeIncludes(dir, "workflows/ci.yml/badge.svg")
+  },
+  {
+    id: "readme-codacy-grade-badge",
+    desc: "README has Codacy grade badge",
+    type: "local",
+    check: (dir) => readmeIncludes(dir, "project/badge/Grade/")
+  },
+  {
+    id: "readme-codacy-coverage-badge",
+    desc: "README has Codacy coverage badge",
+    type: "local",
+    check: (dir) => readmeIncludes(dir, "project/badge/Coverage/")
+  },
+  {
+    id: "readme-npm-badge",
+    desc: "README has npm badge",
+    type: "local",
+    check: (dir) => readmeIncludes(dir, "shields.io/npm/v/")
+  },
+  {
+    id: "editorconfig",
+    desc: ".editorconfig exists",
+    type: "local",
+    check: (dir) => existsSync(path.join(dir, ".editorconfig"))
+  },
+  {
+    id: "codacy-config",
+    desc: ".codacy.yml exists",
+    type: "local",
+    check: (dir) => existsSync(path.join(dir, ".codacy.yml"))
+  },
+  {
+    id: "license",
+    desc: "LICENSE exists",
+    type: "local",
+    check: (dir) => existsSync(path.join(dir, "LICENSE"))
+  },
+  {
+    id: "ci-workflow",
+    desc: "CI workflow exists",
+    type: "local",
+    check: (dir) => existsSync(path.join(dir, ".github/workflows/ci.yml"))
+  },
+  {
+    id: "renovate",
+    desc: "renovate.json exists",
+    type: "local",
+    check: (dir) => existsSync(path.join(dir, "renovate.json"))
+  },
+  {
+    id: "pkg-publint",
+    desc: "publint (all published packages)",
+    type: "local",
+    check: (dir) => eachPublishedPkg(dir, async (pkgDir) => {
+      const { messages } = await publint({ pkgDir });
+      const failures = messages.filter(
+        (m) => m.type === "error" || m.type === "warning"
+      );
+      if (failures.length === 0) return { pass: true };
+      return {
+        pass: false,
+        detail: failures.map((m) => `[${m.type}] ${m.code}`).join("\n")
+      };
+    })
+  },
+  {
+    id: "pkg-attw",
+    desc: "attw (all published packages)",
+    type: "local",
+    check: (dir) => {
+      const bin = findBin("attw", _dirname);
+      if (!bin) return { pass: false, detail: "attw not available" };
+      return eachPublishedPkg(dir, (pkgDir) => {
+        const r = spawnSync(
+          process.execPath,
+          [bin, "--pack", "--profile", "esm-only"],
+          {
+            cwd: pkgDir,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"]
+          }
+        );
+        if (r.status === 0) return { pass: true };
+        return { pass: false, detail: (r.stdout + r.stderr).trim() };
+      });
+    }
+  },
+  {
+    id: "pkg-knip",
+    desc: "knip (no unused exports/deps)",
+    type: "local",
+    check: (dir) => {
+      const bin = findBin("knip", _dirname);
+      if (!bin) return { pass: false, detail: "knip not available" };
+      const r = spawnSync(process.execPath, [bin], {
+        cwd: dir,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+        env: { ...process.env, NO_COLOR: "1" }
+      });
+      if (r.status === 0) return { pass: true };
+      const detail = (r.stdout + r.stderr).trim();
+      return { pass: false, detail: `${detail}
+
+Run: npx knip` };
+    }
+  },
+  {
+    id: "deps-fresh",
+    desc: "dependencies up to date (ncu)",
+    type: "local",
+    check: async (dir) => {
+      const pkg = readPkg(dir);
+      const hasWorkspaces = Array.isArray(pkg?.workspaces) && pkg.workspaces.length > 0;
+      try {
+        const result = await ncuRun({
+          packageFile: path.join(dir, "package.json"),
+          ...hasWorkspaces ? { workspaces: true } : {},
+          silent: true
+        });
+        const entries = hasWorkspaces ? Object.values(
+          result
+        ).flatMap((x) => Object.entries(x)) : Object.entries(result);
+        if (entries.length === 0) return true;
+        const lines = entries.map(([k, v]) => `${k}  \u2192  ${v}`).join("\n");
+        const cmd = hasWorkspaces ? "yarn dlx npm-check-updates --dep dev,optional,peer,prod,packageManager -u --workspaces && yarn install" : "yarn dlx npm-check-updates --dep dev,optional,peer,prod,packageManager -u && yarn install";
+        return { pass: false, detail: `${lines}
+
+Run: ${cmd}` };
+      } catch (error) {
+        return { pass: false, detail: String(error) };
+      }
+    }
+  }
+];
+var listSecrets = (repo) => {
+  try {
+    const result = spawnSync(
+      "gh",
+      ["secret", "list", "--repo", repo, "--json", "name"],
+      {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"]
+      }
+    );
+    if (result.status !== 0) return null;
+    return JSON.parse(result.stdout).map((s) => s.name);
+  } catch {
+    return null;
+  }
+};
+var REMOTE_CHECKS = [
+  {
+    id: "secret-npm-token",
+    desc: "Secret NPM_TOKEN set",
+    type: "remote",
+    check: (repo) => {
+      const secrets = listSecrets(repo);
+      return secrets?.includes("NPM_TOKEN") ?? false;
+    }
+  },
+  {
+    id: "secret-codacy-token",
+    desc: "Secret CODACY_PROJECT_TOKEN set",
+    type: "remote",
+    check: (repo) => {
+      const secrets = listSecrets(repo);
+      return secrets?.includes("CODACY_PROJECT_TOKEN") ?? false;
+    }
+  }
+];
+var CHECKS = [...LOCAL_CHECKS, ...REMOTE_CHECKS];
+
+// src/index.ts
+var checkLocal = async (options = {}) => {
+  const { dir = process.cwd(), skipRemote = false } = options;
+  const repo = options.repo ?? (() => {
+    try {
+      const remote = execSync("git remote get-url origin", {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"]
+      }).trim();
+      const match = /github\.com[:/](.+?)(?:\.git)?$/.exec(remote);
+      return match?.[1] ?? path2.basename(dir);
+    } catch {
+      return dir;
+    }
+  })();
+  const localResults = await Promise.all(
+    LOCAL_CHECKS.map(async (c) => {
+      const raw = await c.check(dir);
+      return typeof raw === "boolean" ? { id: c.id, desc: c.desc, pass: raw } : { id: c.id, desc: c.desc, ...raw };
+    })
+  );
+  const remoteResults = skipRemote ? [] : REMOTE_CHECKS.map((c) => ({
+    id: c.id,
+    desc: c.desc,
+    pass: c.check(repo)
+  }));
+  return { repo, results: [...localResults, ...remoteResults] };
+};
+var checkRepo = async (repo, options = {}) => {
+  const {
+    token,
+    baseDir = path2.join(tmpdir(), "repo-lint"),
+    skipRemote = false
+  } = options;
+  const dir = path2.join(baseDir, repo.replace("/", "__"));
+  if (existsSync2(dir)) {
+    execSync(`git -C ${dir} pull --quiet`, { stdio: "ignore" });
+  } else {
+    const url = token ? `https://${token}@github.com/${repo}.git` : `https://github.com/${repo}.git`;
+    execSync(`git clone --depth 1 --quiet ${url} ${dir}`, { stdio: "ignore" });
+  }
+  const localResults = await Promise.all(
+    LOCAL_CHECKS.map(async (c) => {
+      const raw = await c.check(dir);
+      return typeof raw === "boolean" ? { id: c.id, desc: c.desc, pass: raw } : { id: c.id, desc: c.desc, ...raw };
+    })
+  );
+  const remoteResults = skipRemote ? [] : REMOTE_CHECKS.map((c) => ({
+    id: c.id,
+    desc: c.desc,
+    pass: c.check(repo)
+  }));
+  return { repo, results: [...localResults, ...remoteResults] };
+};
+
+// src/bin.ts
+var { values } = parseArgs({
+  options: {
+    local: { type: "boolean", default: false },
+    repos: { type: "string" },
+    token: { type: "string" },
+    dir: { type: "string", default: `${process.env.HOME ?? "/tmp"}/repo-lint` },
+    "skip-remote": { type: "boolean", default: false }
+  }
+});
+var printReport = (result) => {
+  let anyFail = false;
+  const pass = result.results.filter((r) => r.pass).length;
+  const total = result.results.length;
+  for (const r of result.results) {
+    console.log(`  ${r.pass ? "\u2713" : "\u2717"} ${r.desc}`);
+    if (!r.pass) anyFail = true;
+  }
+  console.log(`
+  ${pass}/${total} checks passed`);
+  return anyFail;
+};
+var main = async () => {
+  let anyFail = false;
+  if (values.local) {
+    console.log(`
+\u2500\u2500 ${process.cwd()}`);
+    const result = await checkLocal({ skipRemote: values["skip-remote"] });
+    anyFail = printReport(result);
+  } else {
+    if (!values.repos) {
+      console.error(
+        "Usage:\n  repo-lint --local                              # check current repo\n  repo-lint --repos lzear/r1,lzear/r2           # check remote repos\nOptions:\n  --token ghp_xxx   GitHub token for private repos\n  --skip-remote     skip secret checks (no gh auth needed)"
+      );
+      process.exit(1);
+    }
+    mkdirSync(values.dir, { recursive: true });
+    for (const repo of values.repos.split(",").map((r) => r.trim())) {
+      console.log(`
+\u2500\u2500 ${repo}`);
+      try {
+        const result = await checkRepo(repo, {
+          token: values.token,
+          baseDir: values.dir,
+          skipRemote: values["skip-remote"]
+        });
+        if (printReport(result)) anyFail = true;
+      } catch {
+        console.log("  \u2717 could not clone repo");
+        anyFail = true;
+      }
+    }
+  }
+  process.exit(anyFail ? 1 : 0);
+};
+void main();

package/dist/index.d.ts

@@ -0,0 +1,46 @@
+interface CheckDetail {
+    pass: boolean;
+    detail?: string;
+}
+type CheckResult$1 = boolean | CheckDetail | Promise<boolean | CheckDetail>;
+interface LocalCheck {
+    id: string;
+    desc: string;
+    type: 'local';
+    check: (dir: string) => CheckResult$1;
+}
+interface RemoteCheck {
+    id: string;
+    desc: string;
+    type: 'remote';
+    check: (repo: string) => boolean;
+}
+type Check = LocalCheck | RemoteCheck;
+declare const LOCAL_CHECKS: LocalCheck[];
+declare const REMOTE_CHECKS: RemoteCheck[];
+declare const CHECKS: Check[];
+
+interface CheckResult {
+    id: string;
+    desc: string;
+    pass: boolean;
+    detail?: string;
+}
+interface RepoReport {
+    repo: string;
+    results: CheckResult[];
+}
+interface CheckRepoOptions {
+    token?: string;
+    baseDir?: string;
+    skipRemote?: boolean;
+}
+interface CheckLocalOptions {
+    dir?: string;
+    skipRemote?: boolean;
+    repo?: string;
+}
+declare const checkLocal: (options?: CheckLocalOptions) => Promise<RepoReport>;
+declare const checkRepo: (repo: string, options?: CheckRepoOptions) => Promise<RepoReport>;
+
+export { CHECKS, type Check, type CheckDetail, type CheckLocalOptions, type CheckRepoOptions, type CheckResult, LOCAL_CHECKS, type LocalCheck, REMOTE_CHECKS, type RemoteCheck, type RepoReport, checkLocal, checkRepo };

package/dist/index.js

@@ -0,0 +1,328 @@
+// src/index.ts
+import { execSync } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import { tmpdir } from "os";
+import path2 from "path";
+
+// src/checks.ts
+import { spawnSync } from "child_process";
+import { existsSync, readFileSync, readdirSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { run as ncuRun } from "npm-check-updates";
+import { publint } from "publint";
+var _dirname = path.dirname(fileURLToPath(import.meta.url));
+var readPkg = (dir) => {
+  const f = path.join(dir, "package.json");
+  if (!existsSync(f)) return null;
+  try {
+    return JSON.parse(readFileSync(f, "utf8"));
+  } catch {
+    return null;
+  }
+};
+var getWorkspacePatterns = (pkg) => {
+  const ws = pkg.workspaces;
+  if (Array.isArray(ws)) return ws;
+  const wsPkg = ws;
+  if (Array.isArray(wsPkg?.packages)) return wsPkg.packages;
+  return [];
+};
+var patternToBase = (rootDir, pattern) => {
+  const parts = pattern.split("/");
+  if (parts.length === 2 && parts[1] === "*")
+    return path.join(rootDir, parts[0] ?? "");
+  if (parts.length === 1 && parts[0] === "*") return rootDir;
+  return null;
+};
+var getWorkspaceDirs = (rootDir) => {
+  const pkg = readPkg(rootDir);
+  if (!pkg) return [];
+  const dirs = [];
+  for (const pattern of getWorkspacePatterns(pkg)) {
+    const base = patternToBase(rootDir, pattern);
+    if (!base || !existsSync(base)) continue;
+    for (const entry of readdirSync(base, { withFileTypes: true })) {
+      if (entry.isDirectory()) dirs.push(path.join(base, entry.name));
+    }
+  }
+  return dirs;
+};
+var findBin = (name, startDir) => {
+  let dir = startDir;
+  while (true) {
+    const bin = path.join(dir, "node_modules", ".bin", name);
+    if (existsSync(bin)) return bin;
+    const parent = path.join(dir, "..");
+    if (parent === dir) return null;
+    dir = parent;
+  }
+};
+var eachPublishedPkg = async (dir, fn) => {
+  const pkg = readPkg(dir);
+  if (!pkg) return { pass: true };
+  if (pkg.private === true) {
+    const wsDirs = getWorkspaceDirs(dir);
+    if (wsDirs.length === 0) return { pass: true };
+    const results = await Promise.all(
+      wsDirs.map((d) => eachPublishedPkg(d, fn))
+    );
+    const failures = results.filter((r) => !r.pass);
+    if (failures.length === 0) return { pass: true };
+    return {
+      pass: false,
+      detail: failures.flatMap((r) => r.detail ? [r.detail] : []).join("\n") || void 0
+    };
+  }
+  return fn(dir);
+};
+var readmeIncludes = (dir, needle) => {
+  const f = path.join(dir, "README.md");
+  return existsSync(f) && readFileSync(f, "utf8").includes(needle);
+};
+var LOCAL_CHECKS = [
+  {
+    id: "readme-exists",
+    desc: "README.md exists",
+    type: "local",
+    check: (dir) => existsSync(path.join(dir, "README.md"))
+  },
+  {
+    id: "readme-ci-badge",
+    desc: "README has CI badge",
+    type: "local",
+    check: (dir) => readmeIncludes(dir, "workflows/ci.yml/badge.svg")
+  },
+  {
+    id: "readme-codacy-grade-badge",
+    desc: "README has Codacy grade badge",
+    type: "local",
+    check: (dir) => readmeIncludes(dir, "project/badge/Grade/")
+  },
+  {
+    id: "readme-codacy-coverage-badge",
+    desc: "README has Codacy coverage badge",
+    type: "local",
+    check: (dir) => readmeIncludes(dir, "project/badge/Coverage/")
+  },
+  {
+    id: "readme-npm-badge",
+    desc: "README has npm badge",
+    type: "local",
+    check: (dir) => readmeIncludes(dir, "shields.io/npm/v/")
+  },
+  {
+    id: "editorconfig",
+    desc: ".editorconfig exists",
+    type: "local",
+    check: (dir) => existsSync(path.join(dir, ".editorconfig"))
+  },
+  {
+    id: "codacy-config",
+    desc: ".codacy.yml exists",
+    type: "local",
+    check: (dir) => existsSync(path.join(dir, ".codacy.yml"))
+  },
+  {
+    id: "license",
+    desc: "LICENSE exists",
+    type: "local",
+    check: (dir) => existsSync(path.join(dir, "LICENSE"))
+  },
+  {
+    id: "ci-workflow",
+    desc: "CI workflow exists",
+    type: "local",
+    check: (dir) => existsSync(path.join(dir, ".github/workflows/ci.yml"))
+  },
+  {
+    id: "renovate",
+    desc: "renovate.json exists",
+    type: "local",
+    check: (dir) => existsSync(path.join(dir, "renovate.json"))
+  },
+  {
+    id: "pkg-publint",
+    desc: "publint (all published packages)",
+    type: "local",
+    check: (dir) => eachPublishedPkg(dir, async (pkgDir) => {
+      const { messages } = await publint({ pkgDir });
+      const failures = messages.filter(
+        (m) => m.type === "error" || m.type === "warning"
+      );
+      if (failures.length === 0) return { pass: true };
+      return {
+        pass: false,
+        detail: failures.map((m) => `[${m.type}] ${m.code}`).join("\n")
+      };
+    })
+  },
+  {
+    id: "pkg-attw",
+    desc: "attw (all published packages)",
+    type: "local",
+    check: (dir) => {
+      const bin = findBin("attw", _dirname);
+      if (!bin) return { pass: false, detail: "attw not available" };
+      return eachPublishedPkg(dir, (pkgDir) => {
+        const r = spawnSync(
+          process.execPath,
+          [bin, "--pack", "--profile", "esm-only"],
+          {
+            cwd: pkgDir,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"]
+          }
+        );
+        if (r.status === 0) return { pass: true };
+        return { pass: false, detail: (r.stdout + r.stderr).trim() };
+      });
+    }
+  },
+  {
+    id: "pkg-knip",
+    desc: "knip (no unused exports/deps)",
+    type: "local",
+    check: (dir) => {
+      const bin = findBin("knip", _dirname);
+      if (!bin) return { pass: false, detail: "knip not available" };
+      const r = spawnSync(process.execPath, [bin], {
+        cwd: dir,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+        env: { ...process.env, NO_COLOR: "1" }
+      });
+      if (r.status === 0) return { pass: true };
+      const detail = (r.stdout + r.stderr).trim();
+      return { pass: false, detail: `${detail}
+
+Run: npx knip` };
+    }
+  },
+  {
+    id: "deps-fresh",
+    desc: "dependencies up to date (ncu)",
+    type: "local",
+    check: async (dir) => {
+      const pkg = readPkg(dir);
+      const hasWorkspaces = Array.isArray(pkg?.workspaces) && pkg.workspaces.length > 0;
+      try {
+        const result = await ncuRun({
+          packageFile: path.join(dir, "package.json"),
+          ...hasWorkspaces ? { workspaces: true } : {},
+          silent: true
+        });
+        const entries = hasWorkspaces ? Object.values(
+          result
+        ).flatMap((x) => Object.entries(x)) : Object.entries(result);
+        if (entries.length === 0) return true;
+        const lines = entries.map(([k, v]) => `${k}  \u2192  ${v}`).join("\n");
+        const cmd = hasWorkspaces ? "yarn dlx npm-check-updates --dep dev,optional,peer,prod,packageManager -u --workspaces && yarn install" : "yarn dlx npm-check-updates --dep dev,optional,peer,prod,packageManager -u && yarn install";
+        return { pass: false, detail: `${lines}
+
+Run: ${cmd}` };
+      } catch (error) {
+        return { pass: false, detail: String(error) };
+      }
+    }
+  }
+];
+var listSecrets = (repo) => {
+  try {
+    const result = spawnSync(
+      "gh",
+      ["secret", "list", "--repo", repo, "--json", "name"],
+      {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"]
+      }
+    );
+    if (result.status !== 0) return null;
+    return JSON.parse(result.stdout).map((s) => s.name);
+  } catch {
+    return null;
+  }
+};
+var REMOTE_CHECKS = [
+  {
+    id: "secret-npm-token",
+    desc: "Secret NPM_TOKEN set",
+    type: "remote",
+    check: (repo) => {
+      const secrets = listSecrets(repo);
+      return secrets?.includes("NPM_TOKEN") ?? false;
+    }
+  },
+  {
+    id: "secret-codacy-token",
+    desc: "Secret CODACY_PROJECT_TOKEN set",
+    type: "remote",
+    check: (repo) => {
+      const secrets = listSecrets(repo);
+      return secrets?.includes("CODACY_PROJECT_TOKEN") ?? false;
+    }
+  }
+];
+var CHECKS = [...LOCAL_CHECKS, ...REMOTE_CHECKS];
+
+// src/index.ts
+var checkLocal = async (options = {}) => {
+  const { dir = process.cwd(), skipRemote = false } = options;
+  const repo = options.repo ?? (() => {
+    try {
+      const remote = execSync("git remote get-url origin", {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"]
+      }).trim();
+      const match = /github\.com[:/](.+?)(?:\.git)?$/.exec(remote);
+      return match?.[1] ?? path2.basename(dir);
+    } catch {
+      return dir;
+    }
+  })();
+  const localResults = await Promise.all(
+    LOCAL_CHECKS.map(async (c) => {
+      const raw = await c.check(dir);
+      return typeof raw === "boolean" ? { id: c.id, desc: c.desc, pass: raw } : { id: c.id, desc: c.desc, ...raw };
+    })
+  );
+  const remoteResults = skipRemote ? [] : REMOTE_CHECKS.map((c) => ({
+    id: c.id,
+    desc: c.desc,
+    pass: c.check(repo)
+  }));
+  return { repo, results: [...localResults, ...remoteResults] };
+};
+var checkRepo = async (repo, options = {}) => {
+  const {
+    token,
+    baseDir = path2.join(tmpdir(), "repo-lint"),
+    skipRemote = false
+  } = options;
+  const dir = path2.join(baseDir, repo.replace("/", "__"));
+  if (existsSync2(dir)) {
+    execSync(`git -C ${dir} pull --quiet`, { stdio: "ignore" });
+  } else {
+    const url = token ? `https://${token}@github.com/${repo}.git` : `https://github.com/${repo}.git`;
+    execSync(`git clone --depth 1 --quiet ${url} ${dir}`, { stdio: "ignore" });
+  }
+  const localResults = await Promise.all(
+    LOCAL_CHECKS.map(async (c) => {
+      const raw = await c.check(dir);
+      return typeof raw === "boolean" ? { id: c.id, desc: c.desc, pass: raw } : { id: c.id, desc: c.desc, ...raw };
+    })
+  );
+  const remoteResults = skipRemote ? [] : REMOTE_CHECKS.map((c) => ({
+    id: c.id,
+    desc: c.desc,
+    pass: c.check(repo)
+  }));
+  return { repo, results: [...localResults, ...remoteResults] };
+};
+export {
+  CHECKS,
+  LOCAL_CHECKS,
+  REMOTE_CHECKS,
+  checkLocal,
+  checkRepo
+};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@lzear/repo-lint",
+  "version": "0.0.1",
+  "description": "Checks lzear repos against forge standards",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lzear/forge.git",
+    "directory": "packages/repo-lint"
+  },
+  "author": "lzear",
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "bin": "./dist/bin.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@arethetypeswrong/cli": "^0.18",
+    "knip": "^6",
+    "npm-check-updates": "^22",
+    "publint": "^0.3"
+  },
+  "devDependencies": {
+    "@lzear/configs": "workspace:*",
+    "@types/node": "^25",
+    "@vitest/coverage-v8": "^4",
+    "tsup": "^8",
+    "typescript": "^6",
+    "vitest": "^4"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}