@fatsolutions/ganchos 1.0.0

package/configs/typescript/.prettierrc

@@ -0,0 +1,8 @@
+{
+  "tabWidth": 4,
+  "endOfLine": "lf",
+  "singleQuote": false,
+  "printWidth": 120,
+  "quoteProps": "preserve",
+  "trailingComma": "es5"
+}

package/configs/typescript/eslint.config.js

@@ -0,0 +1,31 @@
+import eslint from '@eslint/js';
+import tseslint from "typescript-eslint";
+import prettierConfig from 'eslint-config-prettier';
+import { defineConfig } from "eslint/config";
+
+
+export default defineConfig([
+  eslint.configs.recommended,
+  tseslint.configs.strict,
+  tseslint.configs.stylistic,
+  prettierConfig,
+  {
+    plugins: {
+      tseslint
+    },
+    rules: {
+      semi: "error",
+      "prefer-const": "error",
+      "@typescript-eslint/no-non-null-assertion": "warn",
+      "@typescript-eslint/no-unused-vars": [
+        "warn", // Or "error" or "off"
+        {
+          "argsIgnorePattern": "^_",
+          "varsIgnorePattern": "^_",
+          "caughtErrorsIgnorePattern": "^_",
+          "destructuredArrayIgnorePattern": "^_"
+        }
+      ]
+    },
+  },
+]);

package/configs/typescript/install.js

@@ -0,0 +1,16 @@
+export const dependencies = {
+    "eslint": "9.39.2",
+    "@eslint/js": "9.39.2",
+    "eslint-config-prettier": "10.1.8", // includes prettier
+    "typescript-eslint": "8.51.0",
+};
+export const configFiles = [
+    "eslint.config.js",
+    ".prettierrc"
+];
+export function getInstallCommand(deps) {
+    const packages = Object.entries(deps)
+        .map(([name, version]) => `${name}@${version}`)
+        .join(' ');
+    return `pnpm add -D ${packages}`;
+}

package/configs/typescript/install.ts

@@ -0,0 +1,18 @@
+export const dependencies: Record<string, string> = {
+  "eslint": "9.39.2",
+  "@eslint/js": "9.39.2",
+  "eslint-config-prettier": "10.1.8",  // includes prettier
+  "typescript-eslint": "8.51.0",
+};
+
+export const configFiles: string[] = [
+  "eslint.config.js",
+  ".prettierrc"
+];
+
+export function getInstallCommand(deps: Record<string, string>): string {
+  const packages = Object.entries(deps)
+    .map(([name, version]) => `${name}@${version}`)
+    .join(' ');
+  return `pnpm add -D ${packages}`;
+}

package/dist/commands/disable.d.ts

@@ -0,0 +1,3 @@
+declare function disableCommand(languages: string[]): Promise<void>;
+
+export { disableCommand };

package/dist/commands/disable.js

@@ -0,0 +1,18 @@
+import { disableLanguages } from "../lib/config.js";
+async function disableCommand(languages) {
+  const projectRoot = process.cwd();
+  try {
+    await disableLanguages(projectRoot, languages);
+    console.log(`Disabled: ${languages.join(", ")}`);
+    console.log("Run `npx fat-hooks install` to apply changes.");
+  } catch (err) {
+    if (err instanceof Error) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+    throw err;
+  }
+}
+export {
+  disableCommand
+};

package/dist/commands/enable.d.ts

@@ -0,0 +1,3 @@
+declare function enableCommand(languages: string[]): Promise<void>;
+
+export { enableCommand };

package/dist/commands/enable.js

@@ -0,0 +1,25 @@
+import { enableLanguages } from "../lib/config.js";
+import { SUPPORTED_LANGUAGES } from "../types/index.js";
+async function enableCommand(languages) {
+  const projectRoot = process.cwd();
+  for (const lang of languages) {
+    if (!SUPPORTED_LANGUAGES.includes(lang)) {
+      console.warn(`Warning: '${lang}' is not a supported language.`);
+      console.log(`Supported: ${SUPPORTED_LANGUAGES.join(", ")}`);
+    }
+  }
+  try {
+    await enableLanguages(projectRoot, languages);
+    console.log(`Enabled: ${languages.join(", ")}`);
+    console.log("Run `npx fat-hooks install` to apply changes.");
+  } catch (err) {
+    if (err instanceof Error) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+    throw err;
+  }
+}
+export {
+  enableCommand
+};

package/dist/commands/generate.d.ts

@@ -0,0 +1,3 @@
+declare function generateCommand(): Promise<void>;
+
+export { generateCommand };

package/dist/commands/generate.js

@@ -0,0 +1,17 @@
+import { generatePreCommitHook } from "../lib/hooks.js";
+async function generateCommand() {
+  const projectRoot = process.cwd();
+  try {
+    const hookContent = await generatePreCommitHook(projectRoot);
+    process.stdout.write(hookContent);
+  } catch (err) {
+    if (err instanceof Error) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+    throw err;
+  }
+}
+export {
+  generateCommand
+};

package/dist/commands/install.d.ts

@@ -0,0 +1,3 @@
+declare function installCommand(): Promise<void>;
+
+export { installCommand };

package/dist/commands/install.js

@@ -0,0 +1,30 @@
+import { installHook, installHookTools } from "../lib/hooks.js";
+import { readConfig } from "../lib/config.js";
+async function installCommand() {
+  const projectRoot = process.cwd();
+  console.log("Installing git hooks...");
+  try {
+    const config = await readConfig(projectRoot);
+    const enabledLanguages = config.languages.filter((l) => l.enabled).map((l) => l.name);
+    if (enabledLanguages.length === 0) {
+      console.log("No languages enabled. Enable languages first with:");
+      console.log("  npx fat-hooks enable javascript typescript python");
+      return;
+    }
+    await installHookTools(projectRoot);
+    await installHook(projectRoot);
+    console.log(
+      `Generated pre-commit hook with languages: ${enabledLanguages.join(" ")}`
+    );
+    console.log("Git hooks installed successfully!");
+  } catch (err) {
+    if (err instanceof Error) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+    throw err;
+  }
+}
+export {
+  installCommand
+};

package/dist/commands/list.d.ts

@@ -0,0 +1,3 @@
+declare function listCommand(): Promise<void>;
+
+export { listCommand };

package/dist/commands/list.js

@@ -0,0 +1,32 @@
+import { readConfig } from "../lib/config.js";
+import { SUPPORTED_LANGUAGES } from "../types/index.js";
+async function listCommand() {
+  const projectRoot = process.cwd();
+  try {
+    const config = await readConfig(projectRoot);
+    console.log("Configured languages:");
+    for (const lang of config.languages) {
+      const status = lang.enabled ? "enabled" : "disabled";
+      console.log(`  - ${lang.name} (${status})`);
+    }
+    const configuredNames = config.languages.map((l) => l.name);
+    const unconfigured = SUPPORTED_LANGUAGES.filter(
+      (l) => !configuredNames.includes(l)
+    );
+    if (unconfigured.length > 0) {
+      console.log("\nAvailable languages (not configured):");
+      for (const lang of unconfigured) {
+        console.log(`  - ${lang}`);
+      }
+    }
+  } catch (err) {
+    if (err instanceof Error) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+    throw err;
+  }
+}
+export {
+  listCommand
+};

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { installCommand } from "./commands/install.js";
+import { generateCommand } from "./commands/generate.js";
+import { listCommand } from "./commands/list.js";
+import { enableCommand } from "./commands/enable.js";
+import { disableCommand } from "./commands/disable.js";
+const program = new Command();
+program.name("fat-hooks").description("Git Hook Manager for Polyglot Monorepos").version("1.0.0");
+program.command("install").description("Install git hooks based on configuration").action(installCommand);
+program.command("generate").description("Generate hook content to stdout (for inspection)").action(generateCommand);
+program.command("list").description("List configured languages").action(listCommand);
+program.command("enable").description("Enable one or more languages").argument("<languages...>", "Languages to enable").action(enableCommand);
+program.command("disable").description("Disable one or more languages").argument("<languages...>", "Languages to disable").action(disableCommand);
+program.parse();

package/dist/lib/config.d.ts

@@ -0,0 +1,20 @@
+import { FatHooksConfig } from '../types/index.js';
+
+/**
+ * Read configuration from fat-hooks.json, creating default if missing.
+ */
+declare function readConfig(projectRoot: string): Promise<FatHooksConfig>;
+/**
+ * Write configuration to fat-hooks.json.
+ */
+declare function writeConfig(projectRoot: string, config: FatHooksConfig): Promise<void>;
+/**
+ * Enable specified languages in the configuration.
+ */
+declare function enableLanguages(projectRoot: string, languages: string[]): Promise<void>;
+/**
+ * Disable specified languages in the configuration.
+ */
+declare function disableLanguages(projectRoot: string, languages: string[]): Promise<void>;
+
+export { disableLanguages, enableLanguages, readConfig, writeConfig };

package/dist/lib/config.js

@@ -0,0 +1,55 @@
+import fs from "fs/promises";
+import { getConfigPath } from "./paths.js";
+import {
+  DEFAULT_CONFIG,
+  SUPPORTED_LANGUAGES
+} from "../types/index.js";
+async function readConfig(projectRoot) {
+  const configPath = getConfigPath(projectRoot);
+  try {
+    const content = await fs.readFile(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      await writeConfig(projectRoot, DEFAULT_CONFIG);
+      return DEFAULT_CONFIG;
+    }
+    throw err;
+  }
+}
+async function writeConfig(projectRoot, config) {
+  const configPath = getConfigPath(projectRoot);
+  await fs.writeFile(configPath, JSON.stringify(config, null, 2) + "\n");
+}
+async function enableLanguages(projectRoot, languages) {
+  const config = await readConfig(projectRoot);
+  for (const lang of languages) {
+    if (!SUPPORTED_LANGUAGES.includes(lang)) {
+      console.warn(`Warning: Unknown language '${lang}', skipping`);
+      continue;
+    }
+    const langConfig = config.languages.find((l) => l.name === lang);
+    if (langConfig) {
+      langConfig.enabled = true;
+    } else {
+      config.languages.push({ name: lang, enabled: true });
+    }
+  }
+  await writeConfig(projectRoot, config);
+}
+async function disableLanguages(projectRoot, languages) {
+  const config = await readConfig(projectRoot);
+  for (const lang of languages) {
+    const langConfig = config.languages.find((l) => l.name === lang);
+    if (langConfig) {
+      langConfig.enabled = false;
+    }
+  }
+  await writeConfig(projectRoot, config);
+}
+export {
+  disableLanguages,
+  enableLanguages,
+  readConfig,
+  writeConfig
+};

package/dist/lib/hooks.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Generate the aggregated pre-commit hook content.
+ */
+declare function generatePreCommitHook(projectRoot: string): Promise<string>;
+/**
+ * Install the generated hook to .git/hooks/pre-commit.
+ */
+declare function installHook(projectRoot: string): Promise<void>;
+declare function installHookTools(projectRoot: string): Promise<void>;
+
+export { generatePreCommitHook, installHook, installHookTools };

package/dist/lib/hooks.js

@@ -0,0 +1,87 @@
+import fs from "fs/promises";
+import path from "path";
+import { execSync } from "child_process";
+import { getHookScript, getGitHooksDir, getLanguageConfigDir } from "./paths.js";
+import { readConfig } from "./config.js";
+const HOOK_HEADER = `#!/bin/sh
+# Auto-generated pre-commit hook
+# DO NOT EDIT - managed by fat-hooks
+
+set -e
+
+echo "Running pre-commit checks..."
+
+`;
+const HOOK_FOOTER = `
+echo "Pre-commit checks completed successfully!"
+`;
+async function generatePreCommitHook(projectRoot) {
+  const config = await readConfig(projectRoot);
+  const enabledLanguages = config.languages.filter((l) => l.enabled);
+  let hookContent = HOOK_HEADER;
+  for (const lang of enabledLanguages) {
+    const scriptPath = getHookScript("pre-commit", lang.name);
+    try {
+      const script = await fs.readFile(scriptPath, "utf-8");
+      hookContent += `# Language: ${lang.name}
+`;
+      hookContent += script;
+      hookContent += "\n";
+    } catch {
+      console.warn(`Warning: Hook not found for language: ${lang.name}`);
+    }
+  }
+  hookContent += HOOK_FOOTER;
+  return hookContent;
+}
+async function installHook(projectRoot) {
+  const gitDir = path.join(projectRoot, ".git");
+  try {
+    await fs.access(gitDir);
+  } catch {
+    throw new Error("Not in a git repository");
+  }
+  const hooksDir = getGitHooksDir(projectRoot);
+  await fs.mkdir(hooksDir, { recursive: true });
+  const hookContent = await generatePreCommitHook(projectRoot);
+  const hookPath = path.join(hooksDir, "pre-commit");
+  await fs.writeFile(hookPath, hookContent, { mode: 493 });
+}
+async function installHookTools(projectRoot) {
+  const config = await readConfig(projectRoot);
+  const enabledLanguages = config.languages.filter((l) => l.enabled);
+  for (const lang of enabledLanguages) {
+    const langConfigDir = getLanguageConfigDir(lang.name);
+    const installModulePath = path.join(langConfigDir, "install.js");
+    try {
+      await fs.access(installModulePath);
+    } catch {
+      console.log(`No install module for ${lang.name}, skipping tools`);
+      continue;
+    }
+    const installModule = await import(installModulePath);
+    if (installModule.dependencies && installModule.getInstallCommand) {
+      const cmd = installModule.getInstallCommand(installModule.dependencies);
+      console.log(`Installing ${lang.name} tools: ${cmd}`);
+      execSync(cmd, { cwd: projectRoot, stdio: "inherit" });
+    }
+    if (installModule.configFiles) {
+      for (const configFile of installModule.configFiles) {
+        const src = path.join(langConfigDir, configFile);
+        const dest = path.join(projectRoot, configFile);
+        try {
+          await fs.access(dest);
+          console.log(`Config ${configFile} already exists, skipping`);
+        } catch {
+          await fs.copyFile(src, dest);
+          console.log(`Copied ${configFile}`);
+        }
+      }
+    }
+  }
+}
+export {
+  generatePreCommitHook,
+  installHook,
+  installHookTools
+};

package/dist/lib/paths.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Get the path to bundled hooks directory.
+ * Works whether installed globally, locally, or via npx.
+ */
+declare function getHooksDir(): string;
+/**
+ * Get path to a specific hook script.
+ */
+declare function getHookScript(hookType: string, language: string): string;
+/**
+ * Get the user's config file path (in their project root).
+ */
+declare function getConfigPath(projectRoot: string): string;
+/**
+ * Get the .git/hooks directory for the current project.
+ */
+declare function getGitHooksDir(projectRoot: string): string;
+/**
+ * Get the path to bundled configs directory.
+ */
+declare function getConfigsDir(): string;
+/**
+ * Get path to a specific language's config directory.
+ */
+declare function getLanguageConfigDir(language: string): string;
+
+export { getConfigPath, getConfigsDir, getGitHooksDir, getHookScript, getHooksDir, getLanguageConfigDir };

package/dist/lib/paths.js

@@ -0,0 +1,30 @@
+import path from "path";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+function getHooksDir() {
+  return path.resolve(__dirname, "../../hooks");
+}
+function getHookScript(hookType, language) {
+  return path.join(getHooksDir(), hookType, `${language}.sh`);
+}
+function getConfigPath(projectRoot) {
+  return path.join(projectRoot, ".ganchos.json");
+}
+function getGitHooksDir(projectRoot) {
+  return path.join(projectRoot, ".git", "hooks");
+}
+function getConfigsDir() {
+  return path.resolve(__dirname, "../../configs");
+}
+function getLanguageConfigDir(language) {
+  return path.join(getConfigsDir(), language);
+}
+export {
+  getConfigPath,
+  getConfigsDir,
+  getGitHooksDir,
+  getHookScript,
+  getHooksDir,
+  getLanguageConfigDir
+};

package/dist/types/index.d.ts

@@ -0,0 +1,18 @@
+interface LanguageConfig {
+    name: string;
+    enabled: boolean;
+}
+interface LanguageInstallModule {
+    dependencies: Record<string, string>;
+    configFiles: string[];
+    getInstallCommand: (deps: Record<string, string>) => string;
+}
+interface FatHooksConfig {
+    version: string;
+    languages: LanguageConfig[];
+}
+declare const SUPPORTED_LANGUAGES: readonly ["javascript", "typescript", "python"];
+type SupportedLanguage = (typeof SUPPORTED_LANGUAGES)[number];
+declare const DEFAULT_CONFIG: FatHooksConfig;
+
+export { DEFAULT_CONFIG, type FatHooksConfig, type LanguageConfig, type LanguageInstallModule, SUPPORTED_LANGUAGES, type SupportedLanguage };

package/dist/types/index.js

@@ -0,0 +1,13 @@
+const SUPPORTED_LANGUAGES = ["javascript", "typescript", "python"];
+const DEFAULT_CONFIG = {
+  version: "1.0.0",
+  languages: [
+    { name: "javascript", enabled: false },
+    { name: "typescript", enabled: false },
+    { name: "python", enabled: false }
+  ]
+};
+export {
+  DEFAULT_CONFIG,
+  SUPPORTED_LANGUAGES
+};

package/hooks/pre-commit/javascript.sh

@@ -0,0 +1,32 @@
+# JavaScript/Node.js pre-commit hook
+echo "Running JavaScript checks..."
+
+# Check if there are any JS/TS files to check
+JS_FILES=$(git diff --cached --name-only --diff-filter=ACM | grep -E '\.(js|jsx|mjs|cjs)$' || true)
+if [ -n "$JS_FILES" ]; then
+    echo "Checking JavaScript files: $JS_FILES"
+
+    # Get unique package directories from modified files
+    PACKAGES=$(echo "$JS_FILES" | grep '^packages/' | cut -d'/' -f1-2 | sort -u || true)
+
+    # Check if we need to run tools from specific packages
+    HAS_ROOT_JS=$(echo "$JS_FILES" | grep -v '^packages/' || true)
+
+    # Run ESLint on all JavaScript files (from root with proper config detection)
+    if command -v npx >/dev/null 2>&1; then
+        echo "  Running ESLint on JavaScript files..."
+        echo "$JS_FILES" | xargs npx eslint --fix || {
+            echo "ESLint failed. Please fix the issues before committing."
+            exit 1
+        }
+    fi
+
+    # Run Prettier on all JavaScript files (from root)
+    if command -v npx >/dev/null 2>&1; then
+        echo "  Running Prettier on JavaScript files..."
+        echo "$JS_FILES" | xargs npx prettier --write || {
+            echo "Prettier failed. Please fix the issues before committing."
+            exit 1
+        }
+    fi
+fi

package/hooks/pre-commit/python.sh

@@ -0,0 +1,107 @@
+# Python pre-commit hook
+echo "Running Python checks..."
+
+# Check if there are any Python files to check
+PY_FILES=$(git diff --cached --name-only --diff-filter=ACM | grep -E '\.py$' || true)
+if [ -n "$PY_FILES" ]; then
+    echo "Checking Python files: $PY_FILES"
+
+    # Get unique package directories from modified files
+    PACKAGES=$(echo "$PY_FILES" | grep '^packages/' | cut -d'/' -f1-2 | sort -u || true)
+
+    # Check if we have root-level Python files
+    ROOT_PY_FILES=$(echo "$PY_FILES" | grep -v '^packages/' || true)
+
+    # Run tools per package directory (if they have specific configs)
+    for package_dir in $PACKAGES; do
+        PACKAGE_PY_FILES=$(echo "$PY_FILES" | grep "^$package_dir/" || true)
+        if [ -n "$PACKAGE_PY_FILES" ]; then
+            echo "  Checking Python files in $package_dir..."
+
+            # Run tools from package directory if they have local configs
+            if [ -f "$package_dir/pyproject.toml" ] || [ -f "$package_dir/setup.cfg" ]; then
+                (
+                    cd "$package_dir"
+                    RELATIVE_FILES=$(echo "$PACKAGE_PY_FILES" | sed "s|^$package_dir/||")
+
+                    # Run Black formatter if available
+                    if command -v black >/dev/null 2>&1; then
+                        echo "    Running Black formatter in $package_dir..."
+                        echo "$RELATIVE_FILES" | xargs black --check || {
+                            echo "Black formatting failed in $package_dir. Run 'black .' to fix formatting."
+                            exit 1
+                        }
+                    fi
+
+                    # Run isort if available
+                    if command -v isort >/dev/null 2>&1; then
+                        echo "    Running isort in $package_dir..."
+                        echo "$RELATIVE_FILES" | xargs isort --check-only || {
+                            echo "isort failed in $package_dir. Run 'isort .' to fix import sorting."
+                            exit 1
+                        }
+                    fi
+
+                    # Run flake8 if available
+                    if command -v flake8 >/dev/null 2>&1; then
+                        echo "    Running flake8 in $package_dir..."
+                        echo "$RELATIVE_FILES" | xargs flake8 || {
+                            echo "flake8 failed in $package_dir. Please fix the issues before committing."
+                            exit 1
+                        }
+                    fi
+
+                    # Run mypy if available
+                    if command -v mypy >/dev/null 2>&1; then
+                        echo "    Running mypy in $package_dir..."
+                        echo "$RELATIVE_FILES" | xargs mypy || {
+                            echo "mypy failed in $package_dir. Please fix the type issues before committing."
+                            exit 1
+                        }
+                    fi
+                ) || exit 1
+            fi
+        fi
+    done
+
+    # Run tools from root for all Python files (fallback and root files)
+    if [ -n "$ROOT_PY_FILES" ] || [ -z "$PACKAGES" ]; then
+        ALL_FILES="$PY_FILES"
+
+        # Run Black formatter if available
+        if command -v black >/dev/null 2>&1; then
+            echo "  Running Black formatter from root..."
+            echo "$ALL_FILES" | xargs black --check || {
+                echo "Black formatting failed. Run 'black .' to fix formatting."
+                exit 1
+            }
+        fi
+
+        # Run isort if available
+        if command -v isort >/dev/null 2>&1; then
+            echo "  Running isort from root..."
+            echo "$ALL_FILES" | xargs isort --check-only || {
+                echo "isort failed. Run 'isort .' to fix import sorting."
+                exit 1
+            }
+        fi
+
+        # Run flake8 if available
+        if command -v flake8 >/dev/null 2>&1; then
+            echo "  Running flake8 from root..."
+            echo "$ALL_FILES" | xargs flake8 || {
+                echo "flake8 failed. Please fix the issues before committing."
+                exit 1
+            }
+        fi
+
+        # Run mypy if available
+        if command -v mypy >/dev/null 2>&1; then
+            echo "  Running mypy from root..."
+            echo "$ALL_FILES" | xargs mypy || {
+                echo "mypy failed. Please fix the type issues before committing."
+                exit 1
+            }
+        fi
+    fi
+fi

package/hooks/pre-commit/typescript.sh

@@ -0,0 +1,50 @@
+# TypeScript pre-commit hook
+echo "Running TypeScript checks..."
+
+# Check if there are any TS files to check
+TS_FILES=$(git diff --cached --name-only --diff-filter=ACM | grep -E '\.(ts|tsx)$' || true)
+if [ -n "$TS_FILES" ]; then
+    echo "Checking TypeScript files: $TS_FILES"
+
+    # Get unique package directories from modified files
+    PACKAGES=$(echo "$TS_FILES" | grep '^packages/' | cut -d'/' -f1-2 | sort -u || true)
+
+    # Check each package that has TypeScript changes
+    for package_dir in $PACKAGES; do
+        if [ -f "$package_dir/tsconfig.json" ]; then
+            echo "  Running TypeScript compiler check in $package_dir..."
+            (cd "$package_dir" && npx tsc --noEmit -p ./tsconfig.json) || {
+                echo "TypeScript compilation failed in $package_dir. Please fix the issues before committing."
+                exit 1
+            }
+        fi
+    done
+
+    # Run root-level TypeScript check if there are TS files in root or no packages detected
+    ROOT_TS_FILES=$(echo "$TS_FILES" | grep -v '^packages/' || true)
+    if [ -n "$ROOT_TS_FILES" ] && [ -f "tsconfig.json" ]; then
+        echo "  Running TypeScript compiler check in root..."
+        npx tsc --noEmit -p ./tsconfig.json || {
+            echo "TypeScript compilation failed in root. Please fix the issues before committing."
+            exit 1
+        }
+    fi
+
+    # Run ESLint on all TypeScript files (from root with proper config detection)
+    if command -v npx >/dev/null 2>&1; then
+        echo "  Running ESLint on TypeScript files..."
+        echo "$TS_FILES" | xargs npx eslint --fix || {
+            echo "ESLint failed. Please fix the issues before committing."
+            exit 1
+        }
+    fi
+
+    # Run Prettier on all TypeScript files (from root)
+    if command -v npx >/dev/null 2>&1; then
+        echo "  Running Prettier on TypeScript files..."
+        echo "$TS_FILES" | xargs npx prettier --write || {
+            echo "Prettier failed. Please fix the issues before committing."
+            exit 1
+        }
+    fi
+fi

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@fatsolutions/ganchos",
+  "version": "1.0.0",
+  "description": "Git Hook Manager for Polyglot Monorepos, developed in house by FatSolutions",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "ganchos": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "hooks",
+    "configs"
+  ],
+  "keywords": [
+    "git",
+    "hooks",
+    "pre-commit",
+    "monorepo",
+    "linting"
+  ],
+  "author": "FatSolutions",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "commander": "12.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "20.19.29",
+    "tsup": "^8.5.1",
+    "typescript": "5.9.3"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "scripts": {
+    "build": "tsup && tsc -p tsconfig.configs.json",
+    "build:dev": "tsc -p tsconfig.build.json && tsc -p tsconfig.configs.json",
+    "dev": "tsup --watch",
+    "clean": "rm -rf dist configs/**/install.js",
+    "typecheck": "tsc --noEmit",
+    "bundle": "pnpm run clean && pnpm run build"
+  }
+}