@rtorcato/repo-tooling 3.5.0 → 3.7.0

package/dist/languages/python/checks.js

@@ -0,0 +1,234 @@
+/**
+ * Python language module — checks (#290), on the same template as Swift (#286).
+ *
+ * The standard encoded here is ruff (lint *and* format), mypy and pytest.
+ * Deliberately *not* checked:
+ *
+ * - **black** — ruff's formatter is black-compatible and already runs in the
+ *   pre-commit hook and the lint job. A second *rewriting* formatter fights the
+ *   first, which is the same reason the Swift module checks SwiftLint's `--fix`
+ *   rather than SwiftFormat. If a repo wants black instead, it configures black
+ *   in its own pyproject.toml — nothing here objects.
+ * - **flake8 / isort / pyupgrade** — the `select` list in the shipped ruff.toml
+ *   covers all three (E/W, I, UP), so a separate config would be a second place
+ *   to keep the same rules.
+ * - **A pinned interpreter file** (`.python-version`) — the supported range is
+ *   declared once in pyproject's `requires-python`, and CI derives its matrix
+ *   from that. A root file would be a second thing to keep in sync.
+ */
+import path from 'node:path';
+import fs from 'fs-extra';
+import { checkFile } from '../../base/checks.js';
+import { PYTHON_GITIGNORE_SENTINELS } from './gitignore.js';
+import { PYTHON_HOOKS_DIR } from './git-hooks.js';
+const PYTHON_TOOL_CHECKS = [
+    {
+        dedicated: {
+            check: 'Ruff',
+            candidates: ['ruff.toml', '.ruff.toml'],
+            expected: 'is a valid Ruff configuration',
+            // `[tool.ruff...]` is the pyproject form; the rest are ruff.toml's own
+            // top-level keys and sections.
+            matcher: /^\[tool\.ruff|^\[(lint|format)\]|^(line-length|target-version)\s*=/m,
+            hint: 'Run `npx @rtorcato/repo-tooling fix ruff` to scaffold (or add a `[tool.ruff]` table to pyproject.toml)',
+        },
+        shared: ['pyproject.toml'],
+    },
+    {
+        dedicated: {
+            check: 'mypy',
+            candidates: ['mypy.ini', '.mypy.ini'],
+            expected: 'is a valid mypy configuration',
+            // `[mypy]` in mypy.ini/setup.cfg, `[tool.mypy]` in pyproject.
+            matcher: /^\[(tool\.)?mypy\]/m,
+            hint: 'Run `npx @rtorcato/repo-tooling fix mypy` to scaffold (or add a `[tool.mypy]` table to pyproject.toml)',
+        },
+        shared: ['setup.cfg', 'pyproject.toml'],
+    },
+    {
+        dedicated: {
+            check: 'pytest',
+            candidates: ['pytest.ini'],
+            expected: 'is a valid pytest configuration',
+            // `[pytest]` in pytest.ini/tox.ini, `[tool:pytest]` in setup.cfg,
+            // `[tool.pytest.ini_options]` in pyproject.
+            matcher: /^\[(pytest|tool:pytest|tool\.pytest\.ini_options)\]/m,
+            hint: 'Run `npx @rtorcato/repo-tooling fix pytest` to scaffold (or add a `[tool.pytest.ini_options]` table to pyproject.toml)',
+        },
+        shared: ['tox.ini', 'setup.cfg', 'pyproject.toml'],
+    },
+];
+async function checkPythonTool(dir, spec) {
+    const result = await checkFile(dir, spec.dedicated);
+    // A dedicated file that exists takes precedence over any shared table — all
+    // three tools read it first — so `ok` and `drift` are both final answers.
+    if (result.status !== 'missing')
+        return result;
+    for (const candidate of spec.shared) {
+        const filepath = path.join(dir, candidate);
+        if (!(await fs.pathExists(filepath)))
+            continue;
+        if (spec.dedicated.matcher.test(await fs.readFile(filepath, 'utf-8'))) {
+            return {
+                check: spec.dedicated.check,
+                status: 'ok',
+                detail: `${candidate} ${spec.dedicated.expected}`,
+            };
+        }
+    }
+    return result;
+}
+export async function checkPythonGitignore(dir) {
+    const check = 'Python .gitignore';
+    const filepath = path.join(dir, '.gitignore');
+    if (!(await fs.pathExists(filepath))) {
+        return {
+            check,
+            status: 'missing',
+            detail: 'no .gitignore',
+            hint: 'Run `npx @rtorcato/repo-tooling fix python-gitignore` to scaffold the Python template',
+        };
+    }
+    const contents = await fs.readFile(filepath, 'utf-8');
+    const missing = PYTHON_GITIGNORE_SENTINELS.filter((entry) => !contents.includes(entry));
+    if (missing.length > 0) {
+        return {
+            check,
+            status: 'drift',
+            detail: `.gitignore missing Python artefacts: ${missing.join(', ')}`,
+            hint: 'Run `npx @rtorcato/repo-tooling fix python-gitignore` to append the missing entries',
+        };
+    }
+    return {
+        check,
+        status: 'ok',
+        detail: `.gitignore covers ${PYTHON_GITIGNORE_SENTINELS.join(', ')}`,
+    };
+}
+/**
+ * pyproject.toml hygiene, the Python shape of the `Package.swift` check. Both
+ * signals are things no tool infers for you: without a metadata table there is
+ * nothing to build or publish, and without a `requires-python` floor pip will
+ * happily install the package on an interpreter it cannot run on — the failure
+ * lands on the user, at import time.
+ */
+export async function checkPyproject(dir) {
+    const check = 'pyproject.toml';
+    const filepath = path.join(dir, 'pyproject.toml');
+    if (!(await fs.pathExists(filepath))) {
+        // detect-language also accepts setup.py, so a repo can reach this module
+        // without a pyproject at all. That's drift rather than "not a Python repo".
+        const legacy = await fs.pathExists(path.join(dir, 'setup.py'));
+        return {
+            check,
+            status: 'missing',
+            detail: legacy ? 'setup.py only — no pyproject.toml' : 'no pyproject.toml',
+            hint: 'Add a PEP 621 pyproject.toml with a `[project]` table — setup.py is legacy and no longer the packaging standard',
+        };
+    }
+    const contents = await fs.readFile(filepath, 'utf-8');
+    // PEP 621 `[project]` or Poetry's `[tool.poetry]` — the two forms in the wild.
+    const poetry = /^\[tool\.poetry\]/m.test(contents);
+    if (!/^\[project\]/m.test(contents) && !poetry) {
+        return {
+            check,
+            status: 'drift',
+            detail: 'pyproject.toml declares no `[project]` (or `[tool.poetry]`) metadata',
+            hint: 'Add a `[project]` table with `name`, `version` and `requires-python` — see PEP 621',
+        };
+    }
+    // Poetry spells the same constraint `python = "^3.11"` under its dependencies.
+    const hasFloor = poetry
+        ? /^\s*python\s*=/m.test(contents)
+        : /^requires-python\s*=/m.test(contents);
+    if (!hasFloor) {
+        return {
+            check,
+            status: 'drift',
+            detail: `pyproject.toml declares no ${poetry ? '`python` constraint' : '`requires-python`'}`,
+            hint: 'Add `requires-python = ">=3.10"` — without it pip installs the package on interpreters it cannot run on',
+        };
+    }
+    return {
+        check,
+        status: 'ok',
+        detail: `pyproject.toml declares ${poetry ? 'Poetry' : 'PEP 621'} metadata and a Python floor`,
+    };
+}
+/** CI files that could be running the test suite, most likely first. */
+async function ciFiles(dir) {
+    const candidates = ['.gitlab-ci.yml', '.gitlab-ci.yaml'];
+    const workflowsDir = path.join(dir, '.github', 'workflows');
+    if (await fs.pathExists(workflowsDir)) {
+        const files = (await fs.readdir(workflowsDir)).filter((f) => f.endsWith('.yml') || f.endsWith('.yaml'));
+        candidates.unshift(...files.map((f) => path.join('.github', 'workflows', f)));
+    }
+    return candidates;
+}
+/** `tests/`, `test/`, or a root-level `test_*.py` — the three layouts pytest finds. */
+async function hasTestFiles(dir) {
+    for (const candidate of ['tests', 'test']) {
+        if (await fs.pathExists(path.join(dir, candidate)))
+            return `${candidate}/`;
+    }
+    try {
+        const found = (await fs.readdir(dir)).find((f) => /^test_.*\.py$/.test(f));
+        return found ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The test setup. Same two halves as the Swift version: a suite has to exist,
+ * and CI has to run it. A green pipeline over a repo with no tests proves
+ * nothing, and a tests/ directory nothing executes is worse than none at all —
+ * it reads as covered.
+ */
+export async function checkPythonTests(dir) {
+    const check = 'Python tests';
+    const tests = await hasTestFiles(dir);
+    if (!tests) {
+        return {
+            check,
+            status: 'missing',
+            detail: 'no tests/ directory or test_*.py files',
+            hint: 'Add a `tests/` directory — the shipped pytest.ini sets `testpaths = tests`',
+        };
+    }
+    for (const candidate of await ciFiles(dir)) {
+        const filepath = path.join(dir, candidate);
+        if (!(await fs.pathExists(filepath)))
+            continue;
+        if (/\bpytest\b/.test(await fs.readFile(filepath, 'utf-8'))) {
+            return { check, status: 'ok', detail: `${tests} found and run by ${candidate}` };
+        }
+    }
+    return {
+        check,
+        status: 'drift',
+        detail: `${tests} found but no CI job runs pytest`,
+        hint: 'Run `npx @rtorcato/repo-tooling fix python-ci` to regenerate a workflow that runs pytest',
+    };
+}
+/**
+ * The Python shape of the base `Git hooks` / `Pre-push hook` checks (#309).
+ * `install` is null for the same reason Swift's is: the wiring —
+ * `git config core.hooksPath` — is per-clone local state that nothing commits,
+ * so flagging its absence would fail every fresh CI checkout.
+ */
+export const PYTHON_GIT_HOOKS = {
+    dir: PYTHON_HOOKS_DIR,
+    install: null,
+    verifyCommand: 'pytest',
+    fixTarget: 'python-git-hooks',
+};
+/** The Python module's suite, layered on top of the base checks by doctor. */
+export async function runPythonChecks(dir) {
+    return [
+        await checkPyproject(dir),
+        ...(await Promise.all(PYTHON_TOOL_CHECKS.map((spec) => checkPythonTool(dir, spec)))),
+        await checkPythonGitignore(dir),
+        await checkPythonTests(dir),
+    ];
+}

package/dist/languages/python/ci.js

@@ -0,0 +1,153 @@
+/**
+ * Python CI generation (#290), built on the language-agnostic skeleton in
+ * `src/base/ci.ts`. No `setup-node`, no `pnpm` — the Python path runs on Linux
+ * with `actions/setup-python` and pip.
+ *
+ * Like the Swift path there's no `ProjectConfig` to read: the one fact CI needs
+ * beyond the fixed job shapes — which interpreters to test on — is declared in
+ * pyproject.toml, so the matrix is derived from the repo itself.
+ */
+import path from 'node:path';
+import fs from 'fs-extra';
+import { renderGitHubWorkflow, renderGitLabCI } from '../../base/ci.js';
+/**
+ * The newest interpreter the emitted matrix tests against, and the one the
+ * single-interpreter jobs (lint, typecheck) run on.
+ *
+ * ponytail: a constant, bumped by hand once a year when CPython ships a minor.
+ * Resolving "latest" at generation time would need a network call from a
+ * generator whose whole job is emitting text.
+ */
+const LATEST_PYTHON = '3.13';
+/** The oldest interpreter to assume when pyproject declares no floor. */
+const DEFAULT_FLOOR = '3.10';
+const minorOf = (version) => Number.parseInt(version.split('.')[1] ?? '0', 10);
+/**
+ * Pull the supported-Python floor out of a pyproject.toml. A regex rather than
+ * a TOML parser: this is one key, and a parser is a dependency the CLI would
+ * carry solely to read it.
+ */
+export function parsePyproject(contents) {
+    // PEP 621 `requires-python = ">=3.10"`, or Poetry's
+    // `python = "^3.11"` under [tool.poetry.dependencies].
+    const constraint = contents.match(/^requires-python\s*=\s*["']([^"']+)["']/m)?.[1] ??
+        contents.match(/^\s*python\s*=\s*["']([^"']+)["']/m)?.[1] ??
+        '';
+    const floor = constraint.match(/(\d+\.\d+)/)?.[1] ?? DEFAULT_FLOOR;
+    // A floor at or above the newest release we know about collapses the matrix
+    // to one entry rather than emitting a version that doesn't exist yet.
+    const versions = minorOf(floor) >= minorOf(LATEST_PYTHON) ? [floor] : [floor, LATEST_PYTHON];
+    return { pythonVersions: versions };
+}
+export async function readPyproject(dir) {
+    const filepath = path.join(dir, 'pyproject.toml');
+    if (!(await fs.pathExists(filepath)))
+        return { pythonVersions: [DEFAULT_FLOOR, LATEST_PYTHON] };
+    return parsePyproject(await fs.readFile(filepath, 'utf-8'));
+}
+/** Checkout + interpreter. `cache: pip` keys off the manifests pip resolves from. */
+function pythonSetup(version) {
+    return `      - name: 📦 Checkout repository
+        uses: actions/checkout@v7
+
+      - name: 🐍 Set up Python ${version}
+        uses: actions/setup-python@v6
+        with:
+          python-version: '${version}'
+          cache: pip`;
+}
+export function pythonGithubJobs(project) {
+    return [
+        {
+            id: 'lint',
+            steps: `${pythonSetup(LATEST_PYTHON)}
+
+      - name: 📦 Install Ruff
+        run: pip install ruff
+
+      - name: 🔍 ruff check
+        run: ruff check --output-format=github
+
+      - name: 🎨 ruff format --check
+        run: ruff format --check`,
+        },
+        {
+            id: 'typecheck',
+            // mypy needs the package's own dependencies importable to resolve their
+            // types — running it against bare source reports every third-party import
+            // as missing.
+            steps: `${pythonSetup(LATEST_PYTHON)}
+
+      - name: 📦 Install project and mypy
+        run: |
+          pip install --upgrade pip
+          pip install -e .
+          pip install mypy
+
+      - name: 🔎 mypy
+        run: mypy .`,
+        },
+        {
+            id: 'test',
+            extra: `    name: pytest \${{ matrix.python-version }}
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version:
+${project.pythonVersions.map((v) => `          - '${v}'`).join('\n')}`,
+            steps: `      - name: 📦 Checkout repository
+        uses: actions/checkout@v7
+
+      - name: 🐍 Set up Python \${{ matrix.python-version }}
+        uses: actions/setup-python@v6
+        with:
+          python-version: \${{ matrix.python-version }}
+          cache: pip
+
+      - name: 📦 Install project and pytest
+        run: |
+          pip install --upgrade pip
+          pip install -e .
+          pip install pytest
+
+      - name: 🧪 pytest
+        run: pytest`,
+        },
+    ];
+}
+export function renderPythonWorkflow(project) {
+    return renderGitHubWorkflow(pythonGithubJobs(project));
+}
+/**
+ * GitLab runs the same three commands in the official Python image. The matrix
+ * is dropped: GitLab's `parallel:matrix` would need a per-job image override,
+ * and a mirrored repo is a secondary pipeline — the version sweep lives on the
+ * GitHub side.
+ */
+function pythonGitlabSpec(project) {
+    const image = `python:${project.pythonVersions.at(-1) ?? LATEST_PYTHON}`;
+    return {
+        image,
+        preamble: `variables:
+  PIP_CACHE_DIR: "$CI_PROJECT_DIR/.cache/pip"
+
+cache:
+  paths:
+    - .cache/pip`,
+        jobs: [
+            {
+                id: 'lint',
+                stage: 'lint',
+                script: ['pip install ruff', 'ruff check', 'ruff format --check'],
+            },
+            {
+                id: 'test',
+                stage: 'test',
+                script: ['pip install -e .', 'pip install pytest', 'pytest'],
+            },
+        ],
+    };
+}
+export function renderPythonGitLabCI(project) {
+    return renderGitLabCI(pythonGitlabSpec(project));
+}

package/dist/languages/python/fixers.js

@@ -0,0 +1,104 @@
+/**
+ * Python language module — fixers (#290). One per check in ./checks.ts.
+ *
+ * ponytail: no `python-lockfile` fixer. Swift's writes the config that
+ * `setup --preset swift-library` would have produced, and there is no
+ * `python-library` preset yet (the Swift one landed in its own issue, #288).
+ * Inventing a ProjectConfig here just to have something to record would put a
+ * fabricated set of JS tool choices in a Python repo's lockfile — worse than
+ * doctor saying the lockfile is absent, which is true.
+ */
+import path from 'node:path';
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import { copyPreset } from '../../cli/utils/copy-preset.js';
+import { readPyproject, renderPythonGitLabCI, renderPythonWorkflow } from './ci.js';
+import { PYTHON_HOOKS_DIR, installPythonGitHooks } from './git-hooks.js';
+import { ensurePythonGitignore } from './gitignore.js';
+export const PYTHON_FIXERS = [
+    {
+        target: 'ruff',
+        description: 'Scaffold ruff.toml (lint + format — the linter and the formatter in one tool)',
+        appliesTo: ['Ruff'],
+        outputs: ['ruff.toml'],
+        canFixDrift: true,
+        async run({ targetDir }) {
+            const result = await copyPreset('ruff', targetDir);
+            return { filesWritten: [result.target] };
+        },
+    },
+    {
+        target: 'mypy',
+        description: 'Scaffold mypy.ini (strict on your code, lenient on untyped dependencies)',
+        appliesTo: ['mypy'],
+        outputs: ['mypy.ini'],
+        canFixDrift: true,
+        async run({ targetDir }) {
+            const result = await copyPreset('mypy', targetDir);
+            return { filesWritten: [result.target] };
+        },
+    },
+    {
+        target: 'pytest',
+        description: 'Scaffold pytest.ini (strict markers and config, warnings as errors)',
+        appliesTo: ['pytest'],
+        outputs: ['pytest.ini'],
+        canFixDrift: true,
+        async run({ targetDir }) {
+            const result = await copyPreset('pytest', targetDir);
+            return { filesWritten: [result.target] };
+        },
+    },
+    {
+        target: 'python-gitignore',
+        description: 'Add the Python artefacts (__pycache__, .venv, tool caches, build output) to .gitignore',
+        appliesTo: ['Python .gitignore'],
+        // Appends what's missing; never clobbers a project's own entries.
+        riskLevel: 'safe-merge',
+        outputs: ['.gitignore'],
+        canFixDrift: true,
+        async run({ targetDir }) {
+            return { filesWritten: await ensurePythonGitignore(targetDir) };
+        },
+    },
+    {
+        target: 'python-git-hooks',
+        description: `Scaffold ${PYTHON_HOOKS_DIR}/pre-commit + pre-push (ruff, mypy, pytest) and point git at them via core.hooksPath`,
+        appliesTo: ['Git hooks', 'Pre-push hook'],
+        outputs: [`${PYTHON_HOOKS_DIR}/pre-commit`, `${PYTHON_HOOKS_DIR}/pre-push`],
+        canFixDrift: true,
+        async run({ targetDir }) {
+            const { filesWritten, hooksPathSet } = await installPythonGitHooks(targetDir);
+            console.error(hooksPathSet
+                ? chalk.dim(`   git config core.hooksPath ${PYTHON_HOOKS_DIR}`)
+                : chalk.yellow(`   run \`git config core.hooksPath ${PYTHON_HOOKS_DIR}\` once per clone — it's local git config, not a committed file`));
+            return { filesWritten };
+        },
+    },
+    {
+        target: 'python-ci',
+        description: 'Scaffold .github/workflows/ci.yml for Python (ruff, mypy, pytest across the supported interpreters)',
+        appliesTo: ['GitHub Actions'],
+        outputs: ['.github/workflows/ci.yml'],
+        canFixDrift: true,
+        async run({ targetDir }) {
+            const workflowsDir = path.join(targetDir, '.github', 'workflows');
+            await fs.ensureDir(workflowsDir);
+            const workflow = renderPythonWorkflow(await readPyproject(targetDir));
+            await fs.writeFile(path.join(workflowsDir, 'ci.yml'), workflow);
+            return { filesWritten: ['.github/workflows/ci.yml'] };
+        },
+    },
+    {
+        target: 'python-gitlab-ci',
+        description: 'Scaffold .gitlab-ci.yml for Python (ruff + pytest on the official Python image)',
+        appliesTo: ['GitLab CI'],
+        outputs: ['.gitlab-ci.yml'],
+        canFixDrift: true,
+        async run({ targetDir }) {
+            const ci = renderPythonGitLabCI(await readPyproject(targetDir));
+            await fs.writeFile(path.join(targetDir, '.gitlab-ci.yml'), ci);
+            return { filesWritten: ['.gitlab-ci.yml'] };
+        },
+    },
+];

package/dist/languages/python/git-hooks.js

@@ -0,0 +1,35 @@
+/**
+ * Python git hooks (#290). Same shape as the Swift ones (#309) and for the same
+ * reason: Husky is an npm package, and a Python repo has no node on the path to
+ * run it. The committed `.githooks/` directory plus `core.hooksPath` is the
+ * node-free equivalent; the mechanics live in `src/base/git-hooks.ts`.
+ *
+ * Deliberately *not* `pre-commit` (the Python framework of that name): it is a
+ * second config file, a second pinned-tool source, and a second place the CI
+ * commands have to be kept in sync with. The hooks run ruff/mypy/pytest
+ * directly, exactly as CI does.
+ */
+import { installGitHooks } from '../../base/git-hooks.js';
+export const PYTHON_HOOKS_DIR = '.githooks';
+// `ruff format` before `ruff check --fix` so the lint pass sees final layout.
+// Neither rewrites anything the other undoes — one tool owns both jobs.
+const PYTHON_PRE_COMMIT = `#!/bin/sh
+set -e
+ruff format
+ruff check --fix
+`;
+// mypy before pytest: a type error is cheaper to surface than a test run.
+const PYTHON_PRE_PUSH = `#!/bin/sh
+set -e
+echo "🔍 Running pre-push verify..."
+ruff check
+mypy .
+pytest
+echo "✅ Verify passed — pushing."
+`;
+export function installPythonGitHooks(targetDir) {
+    return installGitHooks(targetDir, PYTHON_HOOKS_DIR, {
+        preCommit: PYTHON_PRE_COMMIT,
+        prePush: PYTHON_PRE_PUSH,
+    });
+}

package/dist/languages/python/gitignore.js

@@ -0,0 +1,55 @@
+/**
+ * The Python .gitignore block, shared by the `python-gitignore` fixer and the
+ * check that reports it. Its own module for the same reason Swift's is (#286):
+ * nothing else in the module has to import from `fixers.ts` to reuse it.
+ */
+import path from 'node:path';
+import fs from 'fs-extra';
+/**
+ * The Python artefacts that must stay out of git. Appended to an existing
+ * .gitignore rather than replacing it — a Python repo's ignore file usually
+ * carries project-specific entries worth keeping.
+ */
+const PYTHON_GITIGNORE_BLOCK = `# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+
+# Environments
+.venv/
+venv/
+.env
+
+# Tool caches
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+`;
+/**
+ * Entries whose presence means the block (or an equivalent) is already there.
+ * `__pycache__` and `.venv` are the expensive ones — either committed by
+ * accident buries the diff — and a tool cache stands in for the rest.
+ */
+export const PYTHON_GITIGNORE_SENTINELS = ['__pycache__', '.venv', '.pytest_cache'];
+export async function ensurePythonGitignore(targetDir) {
+    const filepath = path.join(targetDir, '.gitignore');
+    if (!(await fs.pathExists(filepath))) {
+        await fs.writeFile(filepath, PYTHON_GITIGNORE_BLOCK);
+        return ['.gitignore'];
+    }
+    const existing = await fs.readFile(filepath, 'utf-8');
+    const missing = PYTHON_GITIGNORE_SENTINELS.filter((entry) => !existing.includes(entry));
+    if (missing.length === 0)
+        return [];
+    // Append only what's absent, so a repo that already ignores __pycache__
+    // doesn't get a duplicate entry for it.
+    const additions = PYTHON_GITIGNORE_BLOCK.split('\n').filter((line) => line.length > 0 && !existing.includes(line));
+    const separator = existing.endsWith('\n') ? '' : '\n';
+    await fs.writeFile(filepath, `${existing}${separator}\n${additions.join('\n')}\n`);
+    return ['.gitignore'];
+}

package/dist/languages/registry.js

@@ -18,14 +18,14 @@ export const LANGUAGES = {
         label: 'Python',
         codeqlLanguages: ['python'],
         dependabotEcosystem: 'pip',
-        supported: false,
+        supported: true,
     },
     perl: {
         id: 'perl',
         label: 'Perl',
         codeqlLanguages: [],
         dependabotEcosystem: null,
-        supported: false,
+        supported: true,
     },
 };
 /**

package/dist/languages/swift/fixers.js

@@ -93,7 +93,7 @@ export const SWIFT_FIXERS = [
             if (await fs.pathExists(path.join(targetDir, file)))
                 return { filesWritten: [] };
             await fs.outputFile(path.join(targetDir, file), doccLandingPage(target));
-            console.log(chalk.yellow('   add swift-docc-plugin to Package.swift to build it: .package(url: "https://github.com/apple/swift-docc-plugin", from: "1.4.0")'));
+            console.error(chalk.yellow('   add swift-docc-plugin to Package.swift to build it: .package(url: "https://github.com/apple/swift-docc-plugin", from: "1.4.0")'));
             return { filesWritten: [file] };
         },
     },
@@ -117,7 +117,7 @@ export const SWIFT_FIXERS = [
         canFixDrift: true,
         async run({ targetDir }) {
             const { filesWritten, hooksPathSet } = await installSwiftGitHooks(targetDir);
-            console.log(hooksPathSet
+            console.error(hooksPathSet
                 ? chalk.dim(`   git config core.hooksPath ${SWIFT_HOOKS_DIR}`)
                 : chalk.yellow(`   run \`git config core.hooksPath ${SWIFT_HOOKS_DIR}\` once per clone — it's local git config, not a committed file`));
             return { filesWritten };

package/dist/languages/swift/git-hooks.js

@@ -2,16 +2,15 @@
  * Swift git hooks (#309). Husky is an npm package, so a SwiftPM repo can't use
  * it without dragging node into a toolchain that otherwise has none. The
  * node-free equivalent is a committed `.githooks/` directory that git is pointed
- * at with `core.hooksPath`.
+ * at with `core.hooksPath` — the mechanics live in `src/base/git-hooks.ts`; only
+ * the hook bodies are Swift's.
  *
  * The hooks run the tools directly rather than a `verify` indirection: SwiftPM
  * has no scripts field, and inventing a Makefile target would be a third place
  * to keep the CI commands in sync (they already live in .github/workflows/ci.yml
  * and .swiftlint.yml).
  */
-import { execFile } from 'node:child_process';
-import path from 'node:path';
-import fs from 'fs-extra';
+import { installGitHooks } from '../../base/git-hooks.js';
 export const SWIFT_HOOKS_DIR = '.githooks';
 // SwiftLint's --fix is the formatter (see ./checks.ts), so pre-commit formats
 // then lints. --quiet keeps a clean commit from printing a wall of nothing.
@@ -28,36 +27,9 @@ swift test
 swiftlint lint --strict
 echo "✅ Verify passed — pushing."
 `;
-/** Best-effort `git config` — a missing git or a non-repo dir is not a failure. */
-function gitConfig(cwd, key, value) {
-    return new Promise((resolve) => {
-        execFile('git', ['-C', cwd, 'config', key, value], (err) => resolve(!err));
+export function installSwiftGitHooks(targetDir) {
+    return installGitHooks(targetDir, SWIFT_HOOKS_DIR, {
+        preCommit: SWIFT_PRE_COMMIT,
+        prePush: SWIFT_PRE_PUSH,
     });
 }
-/**
- * Writes both hooks and points git at them. Returns the files written —
- * `core.hooksPath` is per-clone local config, not a file, so it's reported
- * separately rather than pretending to be a repo change.
- */
-export async function installSwiftGitHooks(targetDir) {
-    const hooksDir = path.join(targetDir, SWIFT_HOOKS_DIR);
-    await fs.ensureDir(hooksDir);
-    const filesWritten = [];
-    for (const [name, content] of [
-        ['pre-commit', SWIFT_PRE_COMMIT],
-        ['pre-push', SWIFT_PRE_PUSH],
-    ]) {
-        const hookPath = path.join(hooksDir, name);
-        await fs.writeFile(hookPath, content);
-        await fs.chmod(hookPath, 0o755);
-        filesWritten.push(`${SWIFT_HOOKS_DIR}/${name}`);
-    }
-    // Guard on .git: `fix --diff` shadow-runs fixers in a temp copy that excludes
-    // .git, and that copy can land inside another repo — an unguarded `git config`
-    // there would rewrite the *parent* repo's hooksPath during a mere preview.
-    const isRepo = await fs.pathExists(path.join(targetDir, '.git'));
-    const hooksPathSet = isRepo
-        ? await gitConfig(targetDir, 'core.hooksPath', SWIFT_HOOKS_DIR)
-        : false;
-    return { filesWritten, hooksPathSet };
-}