kiln-cli 0.3.1__tar.gz

kiln_cli-0.3.1/.claude-plugin/marketplace.json

@@ -0,0 +1,39 @@
+{
+  "name": "kiln",
+  "description": "Plugins Claude Code des repos kiln",
+  "owner": {
+    "name": "antoine-tena"
+  },
+  "plugins": [
+    {
+      "name": "base",
+      "source": "./plugins/base",
+      "description": "Pour tous les projets : worktrees, fusion, nettoyage, backlog, garde de branche, fichiers protégés, contrôle du fichier modifié, context7"
+    },
+    {
+      "name": "pile-nuxt",
+      "source": "./plugins/pile-nuxt",
+      "description": "Nuxt, Vue, Vitest, audit visuel (polish) et le serveur MCP playwright"
+    },
+    {
+      "name": "pile-django",
+      "source": "./plugins/pile-django",
+      "description": "Django : migrations, contrat OpenAPI, MCP postgres en lecture seule"
+    },
+    {
+      "name": "vps-podman",
+      "source": "./plugins/vps-podman",
+      "description": "VPS en podman-compose : déploiement, diagnostic, copie de la base de prod"
+    },
+    {
+      "name": "stripe",
+      "source": "./plugins/stripe",
+      "description": "MCP Stripe en mode test seulement"
+    },
+    {
+      "name": "serena",
+      "source": "./plugins/serena",
+      "description": "MCP Serena en lecture seule : navigation par symboles pour les gros repos"
+    }
+  ]
+}

kiln_cli-0.3.1/.github/ISSUE_TEMPLATE/bug.yml

@@ -0,0 +1,37 @@
+name: Bug report
+description: Something in kiln, a generated repo or a workflow does not work as expected.
+labels: [bug]
+body:
+  - type: textarea
+    id: what
+    attributes:
+      label: What happened?
+      description: What you ran, what you expected, what you got instead.
+    validations:
+      required: true
+  - type: textarea
+    id: output
+    attributes:
+      label: Output
+      description: The relevant output. `KILN_VERBOSE=1 kiln …` shows the full output of each step.
+      render: shell
+  - type: input
+    id: version
+    attributes:
+      label: kiln version
+      description: The `kiln` line of `kiln doctor` and, in a generated repo, its `modèle` line (template version).
+  - type: input
+    id: stack
+    attributes:
+      label: Stack
+      description: "Backend / frontend / podman, e.g. `django + nuxt, podman`, or `n/a`."
+  - type: dropdown
+    id: os
+    attributes:
+      label: OS
+      options: [Linux, WSL, macOS, Other]
+  - type: input
+    id: claude-code
+    attributes:
+      label: Claude Code version
+      description: For a skill, hook or status line problem, `claude --version`.

kiln_cli-0.3.1/.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,8 @@
+blank_issues_enabled: true
+contact_links:
+  - name: Questions and discussions
+    url: https://github.com/antoine-tena/kiln/discussions
+    about: Ask how to do something, share what you built with kiln.
+  - name: Security vulnerability
+    url: https://github.com/antoine-tena/kiln/security/advisories/new
+    about: Please report vulnerabilities privately.

kiln_cli-0.3.1/.github/ISSUE_TEMPLATE/idea.yml

@@ -0,0 +1,21 @@
+name: Idea or feature request
+description: A new stack, command, rule or improvement.
+labels: [enhancement]
+body:
+  - type: textarea
+    id: problem
+    attributes:
+      label: What problem would this solve?
+    validations:
+      required: true
+  - type: textarea
+    id: proposal
+    attributes:
+      label: What do you have in mind?
+      description: Rough is fine. Alternatives you considered are welcome too.
+  - type: checkboxes
+    id: help
+    attributes:
+      label: Contribution
+      options:
+        - label: I would like to implement this myself.

kiln_cli-0.3.1/.github/pull_request_template.md

@@ -0,0 +1,17 @@
+## What
+
+<!-- What this PR changes, in one or two sentences. -->
+
+## Why
+
+<!-- The need or the bug. Link the issue if there is one: Closes #… -->
+
+## How to test
+
+1.
+
+## Checklist
+
+- [ ] `uv run pytest -q`, `uv run ruff check .`, `uv run mypy src tests` pass
+- [ ] A fixed bug comes with the test that would have caught it
+- [ ] No secrets or real personal data in the diff

kiln_cli-0.3.1/.github/workflows/charte.yml

@@ -0,0 +1,29 @@
+name: Charte
+
+# Les règles impératives de la charte du repo (CLAUDE.md), décrites dans son charte.toml, vérifiées
+# par la commande `charte` de kiln.
+on:
+  workflow_call:
+
+jobs:
+  charte:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          # La règle des migrations compare à la branche d'intégration.
+          fetch-depth: 0
+      # kiln à la version exacte de ce workflow : ses actions et la commande charte en viennent
+      # (retiré aussitôt, pour que les contrôles du projet ne le voient pas).
+      - uses: actions/checkout@v7
+        with:
+          repository: antoine-tena/kiln
+          ref: ${{ job.workflow_sha || 'develop' }}
+          path: .kiln
+      - uses: ./.kiln/actions/charte
+        with:
+          ref: ${{ job.workflow_sha || 'develop' }}
+      - name: Retrait de kiln du dossier du projet
+        run: rm -rf .kiln
+      - name: Charte
+        run: charte

kiln_cli-0.3.1/.github/workflows/contrat-api.yml

@@ -0,0 +1,72 @@
+name: Contrat d'API
+
+# Le front appelle l'API par un client typé depuis openapi.json : ce job régénère le schéma depuis
+# le code Django (django-ninja) puis les types depuis le schéma, et échoue si l'un des fichiers
+# commités a dérivé. Les fichiers engendrés sont ceux de .gitattributes (linguist-generated).
+on:
+  workflow_call:
+    inputs:
+      back:
+        type: string
+        default: backend
+      front:
+        type: string
+        default: frontend
+      export:
+        type: string
+        default: uv run python manage.py export_openapi --check --output ../openapi.json
+      generation:
+        type: string
+        default: pnpm generate:api
+      env:
+        description: Variables du projet, une par ligne (CLE=valeur)
+        type: string
+        default: ""
+
+jobs:
+  contrat:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Variables du projet
+        if: inputs.env != ''
+        env:
+          VARIABLES: ${{ inputs.env }}
+        run: printf '%s\n' "$VARIABLES" | grep -v '^\s*$' >> "$GITHUB_ENV"
+
+      - uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+          package-directory: ./${{ inputs.back }}
+
+      - name: Dépendances du back
+        run: uv sync --locked
+        working-directory: ./${{ inputs.back }}
+
+      - name: openapi.json correspond au code
+        run: ${{ inputs.export }}
+        working-directory: ./${{ inputs.back }}
+
+      - uses: pnpm/action-setup@v6
+        with:
+          package_json_file: ${{ inputs.front }}/package.json
+
+      - uses: actions/setup-node@v7
+        with:
+          node-version-file: ${{ inputs.front }}/.nvmrc
+          cache: pnpm
+          cache-dependency-path: ${{ inputs.front }}/pnpm-lock.yaml
+
+      - name: Dépendances du front
+        run: pnpm install --frozen-lockfile
+        working-directory: ./${{ inputs.front }}
+
+      - name: Types et règles de saisie conformes au schéma
+        env:
+          GENERATION: ${{ inputs.generation }}
+        run: |
+          $GENERATION
+          git diff --exit-code -- ':(top,attr:linguist-generated=true)' \
+            || (echo "::error::Les fichiers engendrés ont dérivé du schéma. Lancer '$GENERATION'." && exit 1)
+        working-directory: ./${{ inputs.front }}

kiln_cli-0.3.1/.github/workflows/django.yml

@@ -0,0 +1,107 @@
+name: Django
+
+# Qualité d'un backend Django géré par uv, contre PostgreSQL et Redis réels (lancés par podman) :
+# sans eux la suite tourne sur SQLite (select_for_update omis, contraintes partielles non
+# exercées) et sur un cache local au process.
+# ruff, typage mypy en cliquet (`charte types`), migrations manquantes, pytest avec couverture,
+# planchers de couverture (`charte couverture`).
+on:
+  workflow_call:
+    inputs:
+      dossier:
+        type: string
+        default: backend
+      base:
+        description: Nom de la base, de son utilisateur et de son mot de passe (préfixe)
+        type: string
+        default: app
+      postgres:
+        type: string
+        default: docker.io/library/postgres:16-alpine
+      redis:
+        description: Image Redis des tests (vide = pas de Redis)
+        type: string
+        default: docker.io/library/redis:7-alpine
+      env:
+        description: Variables du projet pour toutes les étapes, une par ligne (CLE=valeur)
+        type: string
+        default: ""
+      mypy:
+        description: Lancer `charte types` (section [types] de charte.toml)
+        type: boolean
+        default: true
+      couverture:
+        description: Lancer `charte couverture` (section [couverture] de charte.toml)
+        type: boolean
+        default: true
+
+jobs:
+  django:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      # kiln à la version exacte de ce workflow : ses actions et la commande charte en viennent
+      # (retiré aussitôt, pour que les contrôles du projet ne le voient pas).
+      - uses: actions/checkout@v7
+        with:
+          repository: antoine-tena/kiln
+          ref: ${{ job.workflow_sha || 'develop' }}
+          path: .kiln
+      - uses: ./.kiln/actions/charte
+        with:
+          ref: ${{ job.workflow_sha || 'develop' }}
+
+      - uses: ./.kiln/actions/services
+        with:
+          base: ${{ inputs.base }}
+          postgres: ${{ inputs.postgres }}
+          redis: ${{ inputs.redis }}
+      - name: Retrait de kiln du dossier du projet
+        run: rm -rf .kiln
+
+      - name: Variables du projet
+        if: inputs.env != ''
+        env:
+          VARIABLES: ${{ inputs.env }}
+        run: printf '%s\n' "$VARIABLES" | grep -v '^\s*$' >> "$GITHUB_ENV"
+
+      - uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+          package-directory: ./${{ inputs.dossier }}
+
+      - name: Dépendances
+        run: uv sync --locked
+        working-directory: ./${{ inputs.dossier }}
+
+      - name: ruff
+        run: |
+          uv run ruff check .
+          uv run ruff format --check .
+        working-directory: ./${{ inputs.dossier }}
+
+      - name: Typage (mypy, en cliquet)
+        if: inputs.mypy
+        run: charte types
+
+      # Un modèle modifié sans `makemigrations` ne casse aucun test (Django recrée le schéma
+      # depuis les migrations existantes) : il n'apparaissait qu'au `migrate` du déploiement.
+      - name: Aucune migration manquante
+        run: uv run python manage.py makemigrations --check --dry-run
+        working-directory: ./${{ inputs.dossier }}
+
+      - name: pytest
+        run: uv run pytest --cov --cov-branch --cov-report=xml --cov-report=term:skip-covered
+        working-directory: ./${{ inputs.dossier }}
+
+      - name: Publier la couverture
+        if: always()
+        uses: actions/upload-artifact@v7
+        with:
+          name: ${{ inputs.dossier }}-coverage
+          path: ${{ inputs.dossier }}/coverage.xml
+          if-no-files-found: ignore
+
+      - name: Planchers de couverture
+        if: inputs.couverture
+        run: charte couverture

kiln_cli-0.3.1/.github/workflows/infra.yml

@@ -0,0 +1,98 @@
+name: Infra
+
+# Ce qui n'était vérifié que sur le serveur, au pire moment : images de conteneur (podman),
+# workflows GitHub (actionlint), scripts shell (shellcheck), Caddyfile et pile compose.
+# Jamais docker : podman construit et lance, podman-compose (installé par uv) lit le compose.
+on:
+  workflow_call:
+    inputs:
+      image:
+        description: Dossiers des images à construire (contexte et Containerfile), séparés par des espaces
+        type: string
+        default: ""
+      containerfiles:
+        description: Containerfile construits depuis la racine du dépôt, séparés par des espaces
+        type: string
+        default: ""
+      shellcheck:
+        description: Motifs des scripts à relire, séparés par des espaces (vide = rien)
+        type: string
+        default: ""
+      caddyfile:
+        description: Caddyfile à valider (vide = rien)
+        type: string
+        default: ""
+      compose:
+        description: Fichier compose à valider (vide = rien)
+        type: string
+        default: ""
+      preparation:
+        description: Commandes lancées avant la validation du compose (fichiers qu'il attend…)
+        type: string
+        default: ""
+      env:
+        description: Variables pour la validation du compose, une par ligne (CLE=valeur)
+        type: string
+        default: ""
+
+jobs:
+  infra:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+
+      - uses: astral-sh/setup-uv@v7
+
+      - name: Images (podman)
+        if: inputs.image != ''
+        env:
+          DOSSIERS: ${{ inputs.image }}
+        run: |
+          for dossier in $DOSSIERS; do
+            echo "::group::podman build $dossier"
+            podman build --pull -t "ci-${GITHUB_RUN_ID}-$(basename "$dossier")" "$dossier"
+            echo "::endgroup::"
+          done
+
+      - name: Images depuis la racine (podman)
+        if: inputs.containerfiles != ''
+        env:
+          CONTAINERFILES: ${{ inputs.containerfiles }}
+        run: |
+          for containerfile in $CONTAINERFILES; do
+            echo "::group::podman build -f $containerfile ."
+            podman build --pull -f "$containerfile" -t "ci-${GITHUB_RUN_ID}-$(dirname "$containerfile")" .
+            echo "::endgroup::"
+          done
+
+      # Un « : » nu dans un `run:` a déjà rendu un workflow illisible sans que rien ne le signale.
+      # Le shell des `run:` n'est pas relu ici ; les scripts le sont par l'étape suivante.
+      - name: actionlint (workflows GitHub)
+        run: uvx --from actionlint-py actionlint -color -shellcheck= -pyflakes=
+
+      - name: shellcheck
+        if: inputs.shellcheck != ''
+        env:
+          MOTIFS: ${{ inputs.shellcheck }}
+        run: |
+          # shellcheck disable=SC2086 # motifs développés par le shell
+          uvx --from shellcheck-py shellcheck $MOTIFS
+
+      - name: Caddyfile
+        if: inputs.caddyfile != ''
+        run: |
+          podman run --rm -v "$PWD/${{ inputs.caddyfile }}:/etc/caddy/Caddyfile:ro,Z" \
+            docker.io/library/caddy:2 \
+            sh -c 'mkdir -p /var/log/caddy && caddy validate --adapter caddyfile --config /etc/caddy/Caddyfile'
+
+      - name: Pile compose
+        if: inputs.compose != ''
+        env:
+          PREPARATION: ${{ inputs.preparation }}
+          VARIABLES: ${{ inputs.env }}
+        run: |
+          [ -z "$PREPARATION" ] || bash -c "$PREPARATION"
+          set -a
+          eval "$(printf '%s\n' "$VARIABLES" | grep -v '^\s*$')"
+          set +a
+          uvx podman-compose -f "${{ inputs.compose }}" config > /dev/null

kiln_cli-0.3.1/.github/workflows/kiln.yml

@@ -0,0 +1,27 @@
+name: kiln
+
+# Contrôles de kiln lui-même : ruff, mypy, tests du modèle (génération de chaque combinaison).
+on:
+  push:
+    branches: [ main, develop ]
+  pull_request:
+    branches: [ main, develop ]
+
+jobs:
+  kiln:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+      - name: Dépendances
+        run: uv sync --locked
+      - name: ruff
+        run: |
+          uv run ruff check .
+          uv run ruff format --check .
+      - name: mypy
+        run: uv run mypy src tests
+      - name: Tests
+        run: uv run pytest -q

kiln_cli-0.3.1/.github/workflows/maven.yml

@@ -0,0 +1,40 @@
+name: Maven
+
+# Qualité d'un projet Java construit par Maven, sans framework : `./mvnw verify` compile avec les
+# avertissements bloquants, lance les tests JUnit et vérifie le plancher de couverture JaCoCo du
+# pom.xml. Maven vient du wrapper du projet (version et somme SHA-256 figées), jamais du runner.
+on:
+  workflow_call:
+    inputs:
+      dossier:
+        type: string
+        default: backend
+      java:
+        description: Version du JDK
+        type: string
+        default: "25"
+
+jobs:
+  maven:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+
+      - uses: actions/setup-java@v6
+        with:
+          distribution: temurin
+          java-version: ${{ inputs.java }}
+          cache: maven
+          cache-dependency-path: ${{ inputs.dossier }}/pom.xml
+
+      - name: mvnw verify
+        run: ./mvnw -B verify
+        working-directory: ./${{ inputs.dossier }}
+
+      - name: Publier la couverture
+        if: always()
+        uses: actions/upload-artifact@v7
+        with:
+          name: ${{ inputs.dossier }}-coverage
+          path: ${{ inputs.dossier }}/target/site/jacoco/jacoco.xml
+          if-no-files-found: ignore

kiln_cli-0.3.1/.github/workflows/mutation.yml

@@ -0,0 +1,99 @@
+name: Tests par mutation
+
+# mutmut sur un backend Django géré par uv, PostgreSQL et Redis lancés par podman (configuration [tool.mutmut] du pyproject.toml) : un
+# mutant qui survit est un test manquant. Jamais bloquant : le job réussit quel que soit le score
+# et publie le rapport (statistiques, survivants et leur diff) en artefact.
+on:
+  workflow_call:
+    inputs:
+      dossier:
+        type: string
+        default: backend
+      base:
+        type: string
+        default: app
+      postgres:
+        type: string
+        default: docker.io/library/postgres:16-alpine
+      groupe:
+        description: Groupe de dépendances uv qui apporte mutmut
+        type: string
+        default: mutation
+      env:
+        description: Variables du projet, une par ligne (CLE=valeur)
+        type: string
+        default: ""
+
+jobs:
+  mutmut:
+    runs-on: ubuntu-latest
+    timeout-minutes: 330
+    continue-on-error: true
+    defaults:
+      run:
+        working-directory: ./${{ inputs.dossier }}
+    steps:
+      - uses: actions/checkout@v7
+
+      # kiln à la version exacte de ce workflow : ses actions et la commande charte en viennent
+      # (retiré aussitôt, pour que les contrôles du projet ne le voient pas).
+      - uses: actions/checkout@v7
+        with:
+          repository: antoine-tena/kiln
+          ref: ${{ job.workflow_sha || 'develop' }}
+          path: .kiln
+      - uses: ./.kiln/actions/services
+        with:
+          base: ${{ inputs.base }}
+          postgres: ${{ inputs.postgres }}
+          redis: docker.io/library/redis:7-alpine
+      - name: Retrait de kiln du dossier du projet
+        run: rm -rf .kiln
+
+      - name: Variables du projet
+        if: inputs.env != ''
+        env:
+          VARIABLES: ${{ inputs.env }}
+        run: printf '%s\n' "$VARIABLES" | grep -v '^\s*$' >> "$GITHUB_ENV"
+
+      - uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+          package-directory: ./${{ inputs.dossier }}
+
+      - name: Dépendances
+        run: uv sync --locked --group ${{ inputs.groupe }}
+
+      # --max-children 1 : chaque mutant relance pytest sur la même base de test (--reuse-db).
+      - name: mutmut
+        run: uv run mutmut run --max-children 1 || echo "::warning::mutmut s'est arrêté avant la fin"
+
+      - name: Rapport
+        if: always()
+        run: |
+          mkdir -p ../mutation-report
+          uv run mutmut export-cicd-stats || true
+          cp mutants/mutmut-cicd-stats.json ../mutation-report/ 2>/dev/null || true
+          uv run mutmut results --all true > ../mutation-report/mutants.txt 2>&1 || true
+          grep -E ': (survived|no tests|timeout|suspicious)$' ../mutation-report/mutants.txt \
+            > ../mutation-report/survivants.txt || true
+          while read -r name _; do
+            uv run mutmut show "${name%:}" >> ../mutation-report/survivants.diff 2>&1 || true
+          done < ../mutation-report/survivants.txt
+          {
+            echo "## Tests par mutation"
+            echo
+            echo '```json'
+            cat ../mutation-report/mutmut-cicd-stats.json 2>/dev/null || echo "{}"
+            echo '```'
+            echo
+            echo "Survivants : $(wc -l < ../mutation-report/survivants.txt)"
+          } >> "$GITHUB_STEP_SUMMARY"
+
+      - name: Publier le rapport
+        if: always()
+        uses: actions/upload-artifact@v7
+        with:
+          name: mutation-report
+          path: mutation-report/
+          retention-days: 90

kiln_cli-0.3.1/.github/workflows/pnpm.yml

@@ -0,0 +1,83 @@
+name: pnpm
+
+# Qualité d'un front pnpm (Nuxt, Next.js, Astro…) : les scripts de package.json listés dans
+# `scripts`, l'un après l'autre (lint, typecheck, tests, build…), puis les rapports publiés en
+# artefact. La version de pnpm est celle du champ packageManager de package.json.
+on:
+  workflow_call:
+    inputs:
+      dossier:
+        type: string
+        default: frontend
+      pnpm:
+        description: Version de pnpm (vide = champ packageManager de package.json)
+        type: string
+        default: ""
+      scripts:
+        description: Scripts pnpm à lancer dans l'ordre, un par ligne (avec leurs arguments)
+        type: string
+        default: |
+          lint
+          typecheck
+          test
+          build
+      rapports:
+        description: Chemins publiés en artefact, relatifs au dossier, un par ligne
+        type: string
+        default: ""
+
+jobs:
+  pnpm:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ./${{ inputs.dossier }}
+    steps:
+      - uses: actions/checkout@v7
+
+      - uses: pnpm/action-setup@v6
+        with:
+          version: ${{ inputs.pnpm }}
+          package_json_file: ${{ inputs.dossier }}/package.json
+
+      - uses: actions/setup-node@v7
+        with:
+          node-version-file: ${{ inputs.dossier }}/.nvmrc
+          cache: pnpm
+          cache-dependency-path: ${{ inputs.dossier }}/pnpm-lock.yaml
+
+      - name: Dépendances
+        run: pnpm install --frozen-lockfile
+
+      - name: Scripts
+        env:
+          SCRIPTS: ${{ inputs.scripts }}
+        run: |
+          while read -r script; do
+            [ -n "$script" ] || continue
+            echo "::group::pnpm $script"
+            # shellcheck disable=SC2086 # le script porte ses arguments
+            pnpm $script
+            echo "::endgroup::"
+          done <<< "$SCRIPTS"
+
+      - name: Chemins des rapports
+        id: rapports
+        if: always() && inputs.rapports != ''
+        env:
+          RAPPORTS: ${{ inputs.rapports }}
+          DOSSIER: ${{ inputs.dossier }}
+        run: |
+          {
+            echo "chemins<<FIN"
+            while read -r chemin; do [ -n "$chemin" ] && echo "$DOSSIER/$chemin"; done <<< "$RAPPORTS"
+            echo "FIN"
+          } >> "$GITHUB_OUTPUT"
+
+      - name: Publier les rapports
+        if: always() && inputs.rapports != ''
+        uses: actions/upload-artifact@v7
+        with:
+          name: ${{ inputs.dossier }}-rapports
+          path: ${{ steps.rapports.outputs.chemins }}
+          if-no-files-found: ignore