obsidian-plugin-config 1.7.0 → 1.7.2

package/docs/INTERACTIVE_INJECTION.md

@@ -1,137 +1,76 @@
-# Système d'Injection Interactive
+# Injection interactive
 
-## ✅ Fonctionnalité Ajoutée
+L'injection est **interactive par défaut** : elle compare chaque fichier du template
+avec le fichier existant de la cible et ne demande confirmation que lorsque le contenu
+diffère.
 
-Un système de sélection interactive permet maintenant de choisir quels fichiers injecter.
+## Points d'entrée
 
-## Utilisation
-
-### Mode par défaut (tout injecter)
-```bash
-obsidian-inject ../my-plugin
-```
-
-### Mode interactif (choisir quoi injecter)
-```bash
-obsidian-inject ../my-plugin --interactive
-# ou
-obsidian-inject ../my-plugin -i
-```
-
-### Presets rapides
 ```bash
-# Minimal : scripts + package.json + .env
-obsidian-inject ../my-plugin --preset=minimal
-
-# Scripts uniquement
-obsidian-inject ../my-plugin --preset=scripts-only
-
-# Config uniquement (tsconfig, eslint, prettier, etc.)
-obsidian-inject ../my-plugin --preset=config-only
+# CLI globale
+obsidian-inject                 # Injection dans le dossier courant
+obsidian-inject ../my-plugin    # Injection par chemin
+
+# Scripts locaux (développement de ce repo)
+yarn inject-prompt              # Demande le chemin du plugin cible, puis injecte
+yarn inject-path ../my-plugin   # Injection directe par chemin
+yarn check-plugin ../my-plugin  # Dry-run (vérification seule, aucune modification)
 ```
 
-## Options Disponibles
-
-Le mode interactif permet de choisir :
+## Comportement fichier par fichier
 
-1. **scripts** - Scripts (esbuild.config.ts, acp.ts, utils.ts, etc.)
-2. **packageJson** - package.json (scripts & dependencies)
-3. **tsconfig** - tsconfig.json
-4. **eslint** - eslint.config.mts
-5. **prettier** - .prettierrc & .prettierignore
-6. **editorconfig** - .editorconfig
-7. **vscode** - .vscode/ (settings.json, tasks.json, extensions.json)
-8. **github** - .github/workflows/ (release workflow)
-9. **gitignore** - .gitignore
-10. **env** - .env (template)
+Pendant l'injection, chaque fichier est traité ainsi :
 
-## Presets
+- **La cible n'existe pas encore** → le fichier est injecté sans demander.
+- **Contenu identique** → ignoré silencieusement (`✅ ... (unchanged)`).
+- **Contenu différent** → l'outil demande `Update <fichier>? (content differs)`.
+  - `y` → le fichier est remplacé.
+  - `n` → le fichier existant est conservé (`⏭️ Kept existing ...`).
 
-### minimal
-- ✅ scripts
-- ✅ packageJson
-- ✅ env
-- ❌ Tout le reste
+Cas particuliers :
 
-### scripts-only
-- ✅ scripts uniquement
-- ❌ Tout le reste
+- `.env` est toujours **fusionné** : le template est réécrit en préservant les
+  valeurs déjà renseignées (chemins de vault, etc.).
+- `.npmrc` est toujours injecté (protection Yarn).
+- `eslint.config.mts` est approuvé automatiquement si un ancien `.eslintrc*`
+  est détecté (migration depuis l'ancien format).
 
-### config-only
-- ✅ tsconfig
-- ✅ eslint
-- ✅ prettier
-- ✅ editorconfig
-- ✅ vscode
-- ✅ gitignore
-- ❌ scripts, packageJson, github, env
-
-## Exemple d'Utilisation
+## Options
 
 ```bash
-# Lancer en mode interactif
-$ obsidian-inject ../my-plugin -i
-
-🎯 Injection Options
-Select what you want to inject (default: all)
-
-Use default options (inject everything)? [Y/n]: n
-
-📋 Select individual options:
-
-Inject Scripts (esbuild.config.ts, acp.ts, utils.ts, etc.)? [Y/n]: y
-Inject package.json (scripts & dependencies)? [Y/n]: y
-Inject tsconfig.json? [Y/n]: n
-Inject eslint.config.mts? [Y/n]: n
-Inject .prettierrc & .prettierignore? [Y/n]: y
-Inject .editorconfig? [Y/n]: y
-Inject .vscode/ (settings.json, tasks.json, extensions.json)? [Y/n]: y
-Inject .github/workflows/ (release workflow)? [Y/n]: n
-Inject .gitignore? [Y/n]: y
-Inject .env (template)? [Y/n]: y
-
-📋 Selected options:
-   ✅ Scripts (esbuild.config.ts, acp.ts, utils.ts, etc.)
-   ✅ package.json (scripts & dependencies)
-   ❌ tsconfig.json
-   ❌ eslint.config.mts
-   ✅ .prettierrc & .prettierignore
-   ✅ .editorconfig
-   ✅ .vscode/ (settings.json, tasks.json, extensions.json)
-   ❌ .github/workflows/ (release workflow)
-   ✅ .gitignore
-   ✅ .env (template)
-
-Proceed with these options? [Y/n]: y
+# Auto-confirmer tous les remplacements (aucune question)
+obsidian-inject ../my-plugin --no      # CLI globale : --no / -n
+yarn inject-path ../my-plugin --yes    # Scripts locaux : --yes / -y
+
+# Vérification seule (n'écrit rien)
+obsidian-inject ../my-plugin --dry-run
 ```
 
-## Fichiers Concernés
+| Option           | Effet                                              |
+| ---------------- | -------------------------------------------------- |
+| `--no`, `-n`     | (CLI globale) auto-confirme tous les remplacements |
+| `--yes`, `-y`    | (scripts locaux) auto-confirme tous les remplacements |
+| `--dry-run`      | vérification seule, aucune modification            |
 
-1. **scripts/inject-core.ts** - Logique d'injection principale (options support)
-2. **scripts/inject-prompt.ts** - Entrée interactive
-3. **scripts/inject-path.ts** - Entrée CLI avec flags `--interactive` et `--preset`
+## Ce qui est injecté
 
-## Cas d'Usage
+Tous les fichiers du template sont pris en compte à chaque injection (pas de
+sélection par composant) :
 
-### Ne pas écraser esbuild.config.ts existant
-```bash
-obsidian-inject ../my-plugin -i
-# Répondre 'n' à "Inject Scripts"
-```
+- `templates/scripts/*` → `<cible>/scripts/`
+- `templates/tsconfig.json`, `eslint.config.mts`, `.editorconfig`,
+  `.prettierrc`, `.prettierignore`, `.npmrc`, `.env`
+- `templates/.vscode/*`
+- `templates/.github/workflows/*`
+- `templates/gitignore.template` → `<cible>/.gitignore`
 
-### Injecter uniquement les configs
-```bash
-obsidian-inject ../my-plugin --preset=config-only
-```
-
-### Tout sauf GitHub workflows
-```bash
-obsidian-inject ../my-plugin -i
-# Répondre 'n' uniquement à ".github/workflows/"
-```
+La confirmation fichier par fichier permet de conserver un fichier existant
+(par exemple un `esbuild.config.ts` personnalisé) en répondant `n` lorsque la
+question apparaît.
 
-## Notes
+## Fichiers concernés
 
-- Le fichier `.npmrc` est toujours injecté (protection Yarn)
-- En mode non-interactif, tout est injecté par défaut
-- Les options peuvent être combinées : `--interactive --sass`
+1. **scripts/inject-core.ts** — logique d'injection (`diffAndPromptFiles`,
+   `injectScripts`, `updatePackageJson`, `performInjection`).
+2. **scripts/inject-prompt.ts** — entrée interactive (demande le chemin).
+3. **scripts/inject-path.ts** — entrée CLI (parse `--yes`, `--dry-run`).

package/docs/LLM-GUIDE.md

@@ -1,131 +1,130 @@
-# LLM Guide — obsidian-plugin-config
-
-## What this tool does
-
-**obsidian-plugin-config** is a **pure injection tool** that copies scripts and configuration files into Obsidian plugins, making them 100% standalone.
-
----
-
-## Architecture
-
-### templates/ — Source of truth
-
-`templates/` contains everything that gets injected into target plugins:
-
-- `templates/scripts/` — scripts copied into `<target>/scripts/`
-- `templates/package.json` — base deps/scripts merged into `<target>/package.json`
-- `templates/package-sass.json` — additional deps merged when `--sass` flag is used
-- `templates/tsconfig.json` — TypeScript config injected as `<target>/tsconfig.json`
-- `templates/eslint.config.mts` — ESLint config injected into target
-- `templates/.editorconfig`, `templates/.prettierrc`, etc. — config files injected into target
-- `templates/.github/workflows/` — GitHub Actions workflows
-
-### scripts/ — Injection logic
-
-- `scripts/inject-core.ts` — main injection logic
-- `scripts/inject-path.ts` — CLI entry point (parses flags)
-- `scripts/inject-prompt.ts` — interactive injection
-- `scripts/build-npm.ts` — NPM publish workflow
-- `scripts/acp.ts`, `scripts/help.ts`, `scripts/update-version-config.ts`, `scripts/utils.ts` — utilities
-
-### bin/ — Global CLI
-
-- `bin/obsidian-inject.js` — global CLI entry point (generated by build-npm.ts)
-
----
-
-## What injection does
-
-### 1. Package.json merge
-
-`inject-core.ts → updatePackageJson()` reads `templates/package.json` (and `templates/package-sass.json` if `--sass`) and merges into the target plugin's `package.json`:
-
-- All `scripts` are overwritten with template values
-- All `devDependencies` from template are added/updated
-- `engines` and `type` are set from template
-- Target plugin's own specific deps are preserved
-
-### 2. File copying
-
-`inject-core.ts → injectScripts()` copies files from `templates/` into the target:
-
-- `templates/scripts/*` → `<target>/scripts/`
-- `templates/tsconfig.json` → `<target>/tsconfig.json`
-- `templates/eslint.config.mts` → `<target>/eslint.config.mts`
-- `templates/.editorconfig`, `.prettierrc`, `.npmrc`, `.env` → `<target>/`
-- `templates/.github/workflows/*` → `<target>/.github/workflows/`
-- `templates/gitignore.template` → `<target>/.gitignore`
-
-### 3. Traceability
-
-Creates `.injection-info.json` in target with version and date.
-
----
-
-## Template scripts
-
-Scripts in `templates/scripts/` that get copied to target plugins:
-
-**Build system (modular):**
-- `esbuild.config.ts` — build entry point, orchestrates all build modules
-- `constants.ts` — shared constants (external deps list, banner, REST port)
-- `env.ts` — environment validation, manifest check, build path resolution
-- `reload.ts` — Obsidian hot-reload via Local REST API
-- `typingsPlugin.ts` — esbuild plugin for obsidian-typings resolution
-- `utils.ts` — shared utilities (readline, file ops, git, vault path helpers)
-
-**Workflow scripts:**
-- `acp.ts` — add, commit, push workflow
-- `update-version.ts` — version bump utility
-- `release.ts` — GitHub release automation
-- `help.ts` — help documentation
-
----
-
-## SASS support
-
-When `--sass` flag is used:
-
-1. `templates/package-sass.json` deps are merged into target's `package.json`
-2. Adds `esbuild-sass-plugin` dependency
-3. The injected `esbuild.config.ts` automatically detects `.scss` files and uses the plugin
-
-Without `--sass`, the build still works — the SASS import in `esbuild.config.ts` is conditional and only activates if `.scss` files exist.
-
----
-
-## What NOT to do
-
-- ❌ Do not hardcode deps/scripts in `inject-core.ts` — they must come from `templates/package.json`
-- ❌ Do not modify root config files thinking it will affect injected plugins — always modify `templates/`
-- ❌ Do not add `obsidian-plugin-config` as a dependency in `templates/package.json` — injected plugins are standalone
-- ❌ Do not inject `esbuild.config.ts` without its dependencies (`constants.ts`, `env.ts`, `reload.ts`, `typingsPlugin.ts`, `utils.ts`) — they are all required
-
----
-
-## Updating injected content
-
-To change what gets injected:
-
-1. Modify files in `templates/`
-2. Test locally: `yarn inject-path ../test-plugin`
-3. Publish: `yarn npm-publish`
-4. Re-inject into existing plugins to update them
-
----
-
-## obsidian-typings paths
-
-The correct paths for `obsidian-typings` in `templates/tsconfig.json`:
-
-```json
-"types": ["obsidian-typings"],
-"paths": {
-  "obsidian-typings/implementations": [
-    "./node_modules/obsidian-typings/dist/cjs/implementations.d.cts",
-    "./node_modules/obsidian-typings/dist/esm/implementations.mjs"
-  ]
-}
-```
-
-These must stay in sync with the actual `obsidian-typings` package structure.
+# LLM Guide — obsidian-plugin-config
+
+## What this tool does
+
+**obsidian-plugin-config** is a **pure injection tool** that copies scripts and configuration files into Obsidian plugins, making them 100% standalone.
+
+---
+
+## Architecture
+
+### templates/ — Source of truth
+
+`templates/` contains everything that gets injected into target plugins:
+
+- `templates/scripts/` — scripts copied into `<target>/scripts/`
+- `templates/package.json` — base deps/scripts merged into `<target>/package.json`
+- `templates/tsconfig.json` — TypeScript config injected as `<target>/tsconfig.json`
+- `templates/eslint.config.mts` — ESLint config injected into target
+- `templates/.editorconfig`, `templates/.prettierrc`, etc. — config files injected into target
+- `templates/.github/workflows/` — GitHub Actions workflows
+
+### scripts/ — Injection logic
+
+- `scripts/inject-core.ts` — main injection logic
+- `scripts/inject-path.ts` — CLI entry point (parses flags)
+- `scripts/inject-prompt.ts` — interactive injection
+- `scripts/build-npm.ts` — NPM publish workflow
+- `scripts/acp.ts`, `scripts/help.ts`, `scripts/update-version-config.ts`, `scripts/utils.ts` — utilities
+
+### bin/ — Global CLI
+
+- `bin/obsidian-inject.js` — global CLI entry point (generated by build-npm.ts)
+
+---
+
+## What injection does
+
+### 1. Package.json merge
+
+`inject-core.ts → updatePackageJson()` reads `templates/package.json` and merges into the target plugin's `package.json`:
+
+- All `scripts` are overwritten with template values
+- All `devDependencies` from template are added/updated
+- `engines` and `type` are set from template
+- Target plugin's own specific deps are preserved
+
+### 2. File copying
+
+`inject-core.ts → injectScripts()` copies files from `templates/` into the target:
+
+- `templates/scripts/*` → `<target>/scripts/`
+- `templates/tsconfig.json` → `<target>/tsconfig.json`
+- `templates/eslint.config.mts` → `<target>/eslint.config.mts`
+- `templates/.editorconfig`, `.prettierrc`, `.npmrc`, `.env` → `<target>/`
+- `templates/.github/workflows/*` → `<target>/.github/workflows/`
+- `templates/gitignore.template` → `<target>/.gitignore`
+
+### 3. Traceability
+
+Creates `.injection-info.json` in target with version and date.
+
+---
+
+## Template scripts
+
+Scripts in `templates/scripts/` that get copied to target plugins:
+
+**Build system (modular):**
+- `esbuild.config.ts` — build entry point, orchestrates all build modules
+- `constants.ts` — shared constants (external deps list, banner, REST port)
+- `env.ts` — environment validation, manifest check, build path resolution
+- `reload.ts` — Obsidian hot-reload via Local REST API
+- `typingsPlugin.ts` — esbuild plugin for obsidian-typings resolution
+- `utils.ts` — shared utilities (readline, file ops, git, vault path helpers)
+
+**Workflow scripts:**
+- `acp.ts` — add, commit, push workflow
+- `update-version.ts` — version bump utility
+- `release.ts` — GitHub release automation
+- `help.ts` — help documentation
+
+---
+
+## SASS support
+
+SCSS is handled automatically by the injected `esbuild.config.ts`:
+
+1. The build detects `.scss` files (e.g. `src/styles.scss`)
+2. When found, it dynamically imports `esbuild-sass-plugin` and compiles the SCSS
+3. The generated `main.css` is cleaned up after compilation
+
+The `esbuild-sass-plugin` dependency is **not** injected automatically. If a plugin uses SCSS, install it once with `yarn add -D esbuild-sass-plugin` (the build prints a clear warning if it is missing). Plugins without `.scss` files build normally with no extra dependency.
+
+---
+
+## What NOT to do
+
+- ❌ Do not hardcode deps/scripts in `inject-core.ts` — they must come from `templates/package.json`
+- ❌ Do not modify root config files thinking it will affect injected plugins — always modify `templates/`
+- ❌ Do not add `obsidian-plugin-config` as a dependency in `templates/package.json` — injected plugins are standalone
+- ❌ Do not inject `esbuild.config.ts` without its dependencies (`constants.ts`, `env.ts`, `reload.ts`, `typingsPlugin.ts`, `utils.ts`) — they are all required
+
+---
+
+## Updating injected content
+
+To change what gets injected:
+
+1. Modify files in `templates/`
+2. Test locally: `yarn inject-path ../test-plugin`
+3. Publish: `yarn npm-publish`
+4. Re-inject into existing plugins to update them
+
+---
+
+## obsidian-typings paths
+
+The correct paths for `obsidian-typings` in `templates/tsconfig.json`:
+
+```json
+"types": ["obsidian-typings"],
+"paths": {
+  "obsidian-typings/implementations": [
+    "./node_modules/obsidian-typings/dist/cjs/implementations.d.cts",
+    "./node_modules/obsidian-typings/dist/esm/implementations.mjs"
+  ]
+}
+```
+
+These must stay in sync with the actual `obsidian-typings` package structure.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-plugin-config",
-  "version": "1.7.0",
+  "version": "1.7.2",
   "description": "Global CLI injection tool for Obsidian plugins",
   "type": "module",
   "bin": {
@@ -23,7 +23,6 @@
     "prettier": "prettier --check '**/*.{ts,json}'",
     "prettier:fix": "prettier --write '**/*.{ts,json}'",
     "inject-path": "tsx scripts/inject-path.ts",
-    "inject-sass": "tsx scripts/inject-path.ts --sass",
     "inject-prompt": "tsx scripts/inject-prompt.ts",
     "inject": "tsx scripts/inject-prompt.ts",
     "check-plugin": "tsx scripts/inject-path.ts --dry-run",

package/scripts/acp.ts

@@ -11,7 +11,7 @@ import {
 
 const rl = createReadlineInterface();
 
-// Check if we're in the centralized config repo
+/** Check if we're in the centralized config repo */
 function isInCentralizedRepo(): boolean {
   const packageJsonPath = path.join(process.cwd(), 'package.json');
   if (!fs.existsSync(packageJsonPath)) return false;