@forge-ts/cli 0.17.0 → 0.19.0

package/dist/index.js

@@ -1,8 +1,11 @@
 #!/usr/bin/env node
 import {
+  addScripts,
   initProjectCommand,
-  runInitProject
-} from "./chunk-57QAENSK.js";
+  readPkgJson,
+  runInitProject,
+  writePkgJson
+} from "./chunk-JVI2NAXX.js";
 import {
   configureLogger,
   forgeLogger
@@ -473,9 +476,22 @@ var bypassCommand = defineCommand3({
 });
 
 // src/commands/check.ts
+import { execSync } from "child_process";
 import { loadConfig as loadConfig3 } from "@forge-ts/core";
 import { enforce } from "@forge-ts/enforcer";
 import { defineCommand as defineCommand4 } from "citty";
+function getStagedFiles(cwd) {
+  try {
+    const output = execSync("git diff --cached --name-only --diff-filter=d", {
+      cwd,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return output.split("\n").map((f) => f.trim()).filter((f) => f.length > 0 && (f.endsWith(".ts") || f.endsWith(".tsx")));
+  } catch {
+    return null;
+  }
+}
 var RULE_NAMES = {
   E001: "require-summary",
   E002: "require-param",
@@ -634,27 +650,66 @@ async function runCheck(args) {
   if (args.strict !== void 0) {
     config.enforce.strict = args.strict;
   }
+  const fileFilter = args.file;
+  let stagedPaths;
+  if (args.staged) {
+    const rootDir = config.rootDir;
+    const staged = getStagedFiles(rootDir);
+    if (staged !== null && staged.length > 0) {
+      stagedPaths = staged;
+    } else {
+      const data2 = {
+        success: true,
+        summary: { errors: 0, warnings: 0, files: 0, symbols: 0, duration: 0 }
+      };
+      return { operation: "check", success: true, data: data2, duration: 0 };
+    }
+  }
   const result = await enforce(config);
   const mviLevel = args.mvi ?? "standard";
   const limit = args.limit ?? 20;
   const offset = args.offset ?? 0;
-  const filters = { rule: args.rule, file: args.file };
+  const filters = { rule: args.rule, file: fileFilter };
+  const CROSS_FILE_RULES = /* @__PURE__ */ new Set([
+    "E005",
+    "E008",
+    "E009",
+    "E010",
+    "E011",
+    "E012",
+    "W007",
+    "W008",
+    "W009"
+  ]);
+  let filteredErrors = result.errors;
+  let filteredWarnings = result.warnings;
+  if (stagedPaths && stagedPaths.length > 0) {
+    const stagedSet = new Set(stagedPaths);
+    const matchesStaged = (filePath) => stagedPaths?.some((sp) => filePath.endsWith(sp)) ?? false;
+    filteredErrors = result.errors.filter(
+      (e) => CROSS_FILE_RULES.has(e.code) || stagedSet.has(e.filePath) || matchesStaged(e.filePath)
+    );
+    filteredWarnings = result.warnings.filter(
+      (w) => CROSS_FILE_RULES.has(w.code) || stagedSet.has(w.filePath) || matchesStaged(w.filePath)
+    );
+  }
   const exportedSymbolCount = result.symbols.filter((s) => s.exported).length;
   const data = buildCheckResult(
-    result.errors,
-    result.warnings,
+    filteredErrors,
+    filteredWarnings,
     exportedSymbolCount,
     result.duration,
-    result.success,
+    filteredErrors.length === 0,
     mviLevel,
     filters,
     limit,
     offset
   );
-  const cliErrors = result.success ? void 0 : [
+  const checkSuccess = filteredErrors.length === 0;
+  const cliErrors = checkSuccess ? void 0 : [
     {
       code: "FORGE_CHECK_FAILED",
-      message: `TSDoc coverage check failed: ${result.errors.length} error(s), ${result.warnings.length} warning(s) across ${data.summary.files} file(s)`
+      message: `TSDoc coverage check failed: ${filteredErrors.length} error(s), ${filteredWarnings.length} warning(s) across ${data.summary.files} file(s)`
     }
   ];
   const cliWarnings = config._configWarnings?.map((msg) => ({
@@ -666,7 +721,7 @@ async function runCheck(args) {
   }));
   return {
     operation: "check",
-    success: result.success,
+    success: checkSuccess,
     data,
     errors: cliErrors,
     warnings: cliWarnings,
@@ -769,6 +824,11 @@ var checkCommand = defineCommand4({
       type: "string",
       description: "Filter by file path (substring match)"
     },
+    staged: {
+      type: "boolean",
+      description: "Only check symbols from git-staged .ts/.tsx files",
+      default: false
+    },
     limit: {
       type: "string",
       description: "Max file groups in output (default: 20)"
@@ -805,6 +865,7 @@ var checkCommand = defineCommand4({
       mvi: args.mvi,
       rule: args.rule,
       file: args.file,
+      staged: args.staged,
       limit: args.limit ? parseInt(args.limit, 10) : void 0,
       offset: args.offset ? parseInt(args.offset, 10) : void 0
     });
@@ -880,6 +941,7 @@ var docsDevCommand = defineCommand5({
 });
 
 // src/commands/doctor.ts
+import { execSync as execSync2 } from "child_process";
 import { existsSync, readFileSync } from "fs";
 import { mkdir, writeFile } from "fs/promises";
 import { join } from "path";
@@ -1183,43 +1245,136 @@ async function runDoctor(args) {
     });
   }
   const huskyPreCommit = join(rootDir, ".husky", "pre-commit");
+  const huskyPrePush = join(rootDir, ".husky", "pre-push");
   const lefthookYml = join(rootDir, "lefthook.yml");
-  let hookConfigured = false;
-  let hookLocation = "";
+  let hookManagerType = "none";
+  let preCommitConfigured = false;
+  let prePushConfigured = false;
   if (existsSync(huskyPreCommit)) {
+    hookManagerType = "husky";
     try {
       const content = readFileSync(huskyPreCommit, "utf8");
       if (content.includes("forge-ts check")) {
-        hookConfigured = true;
-        hookLocation = "husky pre-commit";
+        preCommitConfigured = true;
+      }
+    } catch {
+    }
+  }
+  if (hookManagerType === "husky" && existsSync(huskyPrePush)) {
+    try {
+      const content = readFileSync(huskyPrePush, "utf8");
+      if (content.includes("forge-ts prepublish")) {
+        prePushConfigured = true;
       }
     } catch {
     }
   }
-  if (!hookConfigured && existsSync(lefthookYml)) {
+  if (hookManagerType === "none" && existsSync(lefthookYml)) {
+    hookManagerType = "lefthook";
     try {
       const content = readFileSync(lefthookYml, "utf8");
       if (content.includes("forge-ts check")) {
-        hookConfigured = true;
-        hookLocation = "lefthook";
+        preCommitConfigured = true;
+      }
+      if (content.includes("forge-ts prepublish")) {
+        prePushConfigured = true;
       }
     } catch {
     }
   }
-  if (hookConfigured) {
-    checks.push({
-      name: "Git hooks",
-      status: "pass",
-      message: `Git hooks \u2014 forge-ts check in ${hookLocation}`,
-      fixable: false
-    });
-  } else {
+  let huskyInstalled = false;
+  if (hookManagerType === "husky" || hookManagerType === "none") {
+    const huskyBin = join(rootDir, "node_modules", ".bin", "husky");
+    if (existsSync(huskyBin)) {
+      huskyInstalled = true;
+    } else {
+      const pkgPathHooks = join(rootDir, "package.json");
+      const hooksPkg = readJsonSafe(pkgPathHooks);
+      if (hooksPkg) {
+        const allDeps = { ...hooksPkg.dependencies, ...hooksPkg.devDependencies };
+        if ("husky" in allDeps) {
+          huskyInstalled = true;
+        }
+      }
+    }
+  }
+  let prepareScriptExists = false;
+  {
+    const pkgPathPrep = join(rootDir, "package.json");
+    const prepPkg = readJsonSafe(pkgPathPrep);
+    if (prepPkg?.scripts?.prepare) {
+      prepareScriptExists = true;
+    }
+  }
+  if (hookManagerType === "husky") {
+    try {
+      execSync2("git config core.hooksPath", {
+        cwd: rootDir,
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } catch {
+    }
+  }
+  if (hookManagerType === "none" && !preCommitConfigured && !prePushConfigured) {
     checks.push({
       name: "Git hooks",
       status: "warn",
-      message: "Git hooks \u2014 forge-ts check not in pre-commit (run forge-ts init hooks)",
+      message: "Git hooks \u2014 no hook manager detected (run forge-ts init hooks)",
       fixable: false
     });
+  } else if (hookManagerType === "husky") {
+    if (!huskyInstalled) {
+      checks.push({
+        name: "Git hooks (husky)",
+        status: "warn",
+        message: "Git hooks \u2014 hook files exist but husky is not installed (run: npm install -D husky)",
+        fixable: false
+      });
+    } else if (!prepareScriptExists) {
+      checks.push({
+        name: "Git hooks (husky)",
+        status: "warn",
+        message: 'Git hooks \u2014 husky installed but "prepare" script missing in package.json',
+        fixable: false
+      });
+    } else if (preCommitConfigured && prePushConfigured) {
+      checks.push({
+        name: "Git hooks (husky)",
+        status: "pass",
+        message: "Git hooks \u2014 husky installed, prepare script wired, pre-commit and pre-push configured",
+        fixable: false
+      });
+    } else {
+      const missing = [];
+      if (!preCommitConfigured) missing.push("pre-commit (forge-ts check)");
+      if (!prePushConfigured) missing.push("pre-push (forge-ts prepublish)");
+      checks.push({
+        name: "Git hooks (husky)",
+        status: "warn",
+        message: `Git hooks \u2014 husky installed but missing: ${missing.join(", ")}`,
+        fixable: false
+      });
+    }
+  } else if (hookManagerType === "lefthook") {
+    if (preCommitConfigured && prePushConfigured) {
+      checks.push({
+        name: "Git hooks (lefthook)",
+        status: "pass",
+        message: "Git hooks \u2014 lefthook pre-commit and pre-push configured",
+        fixable: false
+      });
+    } else {
+      const missing = [];
+      if (!preCommitConfigured) missing.push("pre-commit (forge-ts check)");
+      if (!prePushConfigured) missing.push("pre-push (forge-ts prepublish)");
+      checks.push({
+        name: "Git hooks (lefthook)",
+        status: "warn",
+        message: `Git hooks \u2014 lefthook detected but missing: ${missing.join(", ")}`,
+        fixable: false
+      });
+    }
   }
   const summary = {
     passed: checks.filter((c) => c.status === "pass").length,
@@ -1597,15 +1752,19 @@ function detectHookManager(rootDir) {
   }
   return "none";
 }
-var HUSKY_PRE_COMMIT = `#!/usr/bin/env sh
-. "$(dirname -- "$0")/_/husky.sh"
-
-npx forge-ts check
+var HUSKY_PRE_COMMIT = `npx forge-ts check
+`;
+var HUSKY_PRE_PUSH = `npx forge-ts prepublish
 `;
 var LEFTHOOK_BLOCK = `pre-commit:
   commands:
     forge-ts-check:
       run: npx forge-ts check
+
+pre-push:
+  commands:
+    forge-ts-prepublish:
+      run: npx forge-ts prepublish
 `;
 async function runInitHooks(args) {
   const start = Date.now();
@@ -1616,54 +1775,125 @@ async function runInitHooks(args) {
   const warnings = [];
   const instructions = [];
   if (hookManager === "husky" || hookManager === "none") {
+    const huskyBin = join3(rootDir, "node_modules", ".bin", "husky");
+    const pkg2 = readPkgJson(rootDir);
+    const huskyInDeps = pkg2 !== null && ("husky" in (pkg2.obj.devDependencies ?? {}) || "husky" in (pkg2.obj.dependencies ?? {}));
+    const huskyInstalled = existsSync3(huskyBin) || huskyInDeps;
+    if (!huskyInstalled) {
+      warnings.push({
+        code: "HOOKS_HUSKY_NOT_INSTALLED",
+        message: "husky not installed. Run: npm install -D husky"
+      });
+      instructions.push("husky is not installed. Run: npm install -D husky (or pnpm add -D husky)");
+    }
     const huskyDir = join3(rootDir, ".husky");
-    const hookPath = join3(huskyDir, "pre-commit");
-    const relativePath = ".husky/pre-commit";
-    if (existsSync3(hookPath) && !args.force) {
-      const existing = await readFile(hookPath, "utf8");
+    const preCommitPath = join3(huskyDir, "pre-commit");
+    const preCommitRel = ".husky/pre-commit";
+    if (existsSync3(preCommitPath) && !args.force) {
+      const existing = await readFile(preCommitPath, "utf8");
       if (existing.includes("forge-ts check")) {
-        skippedFiles.push(relativePath);
+        skippedFiles.push(preCommitRel);
         warnings.push({
           code: "HOOKS_ALREADY_EXISTS",
-          message: `${relativePath} already contains forge-ts check \u2014 skipping. Use --force to overwrite.`
+          message: `${preCommitRel} already contains forge-ts check \u2014 skipping. Use --force to overwrite.`
         });
       } else {
         const appended = `${existing.trimEnd()}
 
 npx forge-ts check
 `;
-        await writeFile3(hookPath, appended, { mode: 493 });
-        writtenFiles.push(relativePath);
+        await writeFile3(preCommitPath, appended, { mode: 493 });
+        writtenFiles.push(preCommitRel);
       }
     } else {
       await mkdir3(huskyDir, { recursive: true });
-      await writeFile3(hookPath, HUSKY_PRE_COMMIT, { mode: 493 });
-      writtenFiles.push(relativePath);
+      await writeFile3(preCommitPath, HUSKY_PRE_COMMIT, { mode: 493 });
+      writtenFiles.push(preCommitRel);
+    }
+    const prePushPath = join3(huskyDir, "pre-push");
+    const prePushRel = ".husky/pre-push";
+    if (existsSync3(prePushPath) && !args.force) {
+      const existing = await readFile(prePushPath, "utf8");
+      if (existing.includes("forge-ts prepublish")) {
+        skippedFiles.push(prePushRel);
+        warnings.push({
+          code: "HOOKS_ALREADY_EXISTS",
+          message: `${prePushRel} already contains forge-ts prepublish \u2014 skipping. Use --force to overwrite.`
+        });
+      } else {
+        const appended = `${existing.trimEnd()}
+
+npx forge-ts prepublish
+`;
+        await writeFile3(prePushPath, appended, { mode: 493 });
+        writtenFiles.push(prePushRel);
+      }
+    } else {
+      await mkdir3(huskyDir, { recursive: true });
+      await writeFile3(prePushPath, HUSKY_PRE_PUSH, { mode: 493 });
+      writtenFiles.push(prePushRel);
+    }
+    const pkgData = readPkgJson(rootDir);
+    if (pkgData) {
+      const added = addScripts(pkgData, { prepare: "husky" });
+      if (added.length > 0) {
+        await writePkgJson(pkgData);
+        writtenFiles.push("package.json (prepare script)");
+        instructions.push('Added "prepare": "husky" script to package.json.');
+      } else {
+        skippedFiles.push("package.json (prepare script already exists)");
+      }
     }
     if (hookManager === "none") {
       instructions.push(
-        "No hook manager detected. Wrote .husky/pre-commit as a starting point.",
-        "Install husky to activate: npx husky-init && npm install (or pnpm dlx husky-init && pnpm install)"
+        "No hook manager detected. Wrote .husky/pre-commit and .husky/pre-push as a starting point.",
+        "Install husky to activate: npm install -D husky && npx husky (or pnpm add -D husky && pnpm exec husky)"
       );
     } else {
       instructions.push("Husky pre-commit hook configured to run forge-ts check.");
+      instructions.push("Husky pre-push hook configured to run forge-ts prepublish.");
     }
   } else if (hookManager === "lefthook") {
     const lefthookPath = join3(rootDir, "lefthook.yml");
     const relativePath = "lefthook.yml";
     if (existsSync3(lefthookPath)) {
       const existing = await readFile(lefthookPath, "utf8");
-      if (existing.includes("forge-ts check") && !args.force) {
+      const hasCheck = existing.includes("forge-ts check");
+      const hasPrepublish = existing.includes("forge-ts prepublish");
+      if (hasCheck && hasPrepublish && !args.force) {
         skippedFiles.push(relativePath);
         warnings.push({
           code: "HOOKS_ALREADY_EXISTS",
-          message: `${relativePath} already contains forge-ts check \u2014 skipping. Use --force to overwrite.`
+          message: `${relativePath} already contains forge-ts check and prepublish \u2014 skipping. Use --force to overwrite.`
         });
-      } else if (existing.includes("pre-commit:") && !args.force) {
+      } else if (hasCheck && !hasPrepublish && !args.force) {
+        const prePushBlock = `
+pre-push:
+  commands:
+    forge-ts-prepublish:
+      run: npx forge-ts prepublish
+`;
         const appended = `${existing.trimEnd()}
-    forge-ts-check:
-      run: npx forge-ts check
+${prePushBlock}`;
+        await writeFile3(lefthookPath, appended, "utf8");
+        writtenFiles.push(relativePath);
+      } else if (existing.includes("pre-commit:") && !args.force) {
+        let appended = existing.trimEnd();
+        if (!hasCheck) {
+          appended += "\n    forge-ts-check:\n      run: npx forge-ts check";
+        }
+        if (!existing.includes("pre-push:")) {
+          appended += `
+
+pre-push:
+  commands:
+    forge-ts-prepublish:
+      run: npx forge-ts prepublish
 `;
+        } else if (!hasPrepublish) {
+          appended += "\n    forge-ts-prepublish:\n      run: npx forge-ts prepublish";
+        }
+        appended += "\n";
         await writeFile3(lefthookPath, appended, "utf8");
         writtenFiles.push(relativePath);
       } else {
@@ -1678,6 +1908,7 @@ ${LEFTHOOK_BLOCK}`;
       writtenFiles.push(relativePath);
     }
     instructions.push("Lefthook pre-commit hook configured to run forge-ts check.");
+    instructions.push("Lefthook pre-push hook configured to run forge-ts prepublish.");
   }
   const data = {
     success: true,
@@ -2341,7 +2572,7 @@ var initCommand2 = defineCommand13({
     if (hasSubCommand) {
       return;
     }
-    const { runInitProject: runInitProject2 } = await import("./init-project-PT4XOWV2.js");
+    const { runInitProject: runInitProject2 } = await import("./init-project-6CWF4CCX.js");
     const { emitResult: emitResult2, resolveExitCode: resolveExitCode2 } = await import("./output-OSCHMPOX.js");
     const { forgeLogger: forgeLogger2 } = await import("./forge-logger-RTOBEKWH.js");
     const output = await runInitProject2({