obsidian-plugin-config 1.5.12 → 1.6.0

package/docs/INTERACTIVE_INJECTION.md

@@ -0,0 +1,137 @@
+# Système d'Injection Interactive
+
+## ✅ Fonctionnalité Ajoutée
+
+Un système de sélection interactive permet maintenant de choisir quels fichiers injecter.
+
+## 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
+```
+
+## Options Disponibles
+
+Le mode interactif permet de choisir :
+
+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)
+
+## Presets
+
+### minimal
+- ✅ scripts
+- ✅ packageJson
+- ✅ env
+- ❌ Tout le reste
+
+### scripts-only
+- ✅ scripts uniquement
+- ❌ Tout le reste
+
+### config-only
+- ✅ tsconfig
+- ✅ eslint
+- ✅ prettier
+- ✅ editorconfig
+- ✅ vscode
+- ✅ gitignore
+- ❌ scripts, packageJson, github, env
+
+## Exemple d'Utilisation
+
+```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
+```
+
+## Fichiers Modifiés
+
+1. **scripts/inject-options.ts** (nouveau) - Gestion des options
+2. **scripts/inject-core.ts** - Ajout paramètre `options` aux fonctions
+3. **scripts/inject-path.ts** - Ajout flags `--interactive` et `--preset`
+
+## Cas d'Usage
+
+### Ne pas écraser esbuild.config.ts existant
+```bash
+obsidian-inject ../my-plugin -i
+# Répondre 'n' à "Inject Scripts"
+```
+
+### 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/"
+```
+
+## Notes
+
+- 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`

package/docs/LLM-GUIDE.md

@@ -1,91 +1,112 @@
 # LLM Guide — obsidian-plugin-config
 
-## The two distinct roles of this repo
+## What this tool does
 
-### 1. Local plugin (root)
+**obsidian-plugin-config** is a **pure injection tool** that copies scripts and configuration files into Obsidian plugins, making them 100% standalone.
 
-The root of this repo functions as a **local Obsidian plugin** for development and testing purposes.
-
-- `src/` — reusable code (modals, utils, helpers) that can be tested locally and exported via NPM
-- `scripts/` — local build/dev scripts for this repo itself (includes `build-npm.ts` for NPM publishing)
-- `package.json` (root) — configuration for this local plugin + NPM package
-- `tsconfig.json` (root) — TypeScript config for this local plugin
-- `eslint.config.mts` (root) — ESLint config for this local plugin
+---
 
-Exports from `src/` are available as snippets via the NPM package `obsidian-plugin-config`.
+## Architecture
 
-### 2. Injection system (templates/)
+### templates/ — Source of truth
 
-`templates/` is the **source of truth** for everything injected into target plugins.
+`templates/` contains everything that gets injected into target plugins:
 
-- `templates/scripts/` — scripts that will be copied into `<target>/scripts/`
+- `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/help-plugin.ts` — help script injected as `<target>/scripts/help.ts`
+- `templates/.github/workflows/` — GitHub Actions workflows
 
-The injection logic lives in `scripts/inject-core.ts`, `scripts/inject-path.ts`, `scripts/inject-prompt.ts`.
-
----
+### scripts/ — Injection logic
 
-## Critical distinction
+- `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
 
-| | Root | templates/ |
-|---|---|---|
-| Purpose | Local dev + NPM exports | Source for injection |
-| package.json | This repo's own config | Base for target plugins |
-| tsconfig.json | This repo's TS config | Injected into targets |
-| scripts/ | Local scripts (+ build-npm) | Copied into targets |
+### bin/ — Global CLI
 
-**Never modify root config files thinking it will affect injected plugins. Always modify `templates/`.**
-
-**Never read root `package.json` or `tsconfig.json` as a reference for what gets injected.**
+- `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.
 
 ---
 
-## Scripts: local vs injected
+## Template scripts
+
+Scripts in `templates/scripts/` that get copied to target plugins:
+
+- `esbuild.config.ts` — build configuration (handles SASS automatically)
+- `acp.ts` — add, commit, push workflow
+- `update-version.ts` — version bump utility
+- `release.ts` — GitHub release automation
+- `utils.ts` — shared utilities
+- `help.ts` — help documentation
 
-Local scripts (`scripts/`) and template scripts (`templates/scripts/`) are **the same scripts**, with one difference:
+---
+
+## SASS support
 
-- `scripts/` has extra files: `inject-core.ts`, `inject-path.ts`, `inject-prompt.ts`, `build-npm.ts`, `update-exports.js`, `update-version-config.ts`
-- `templates/scripts/` has only what target plugins need: `esbuild.config.ts`, `acp.ts`, `update-version.ts`, `release.ts`, `utils.ts`, `help.ts`
+When `--sass` flag is used:
 
-When updating a shared script (e.g. `acp.ts`), update **both** `scripts/acp.ts` and `templates/scripts/acp.ts`.
+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
 
 ---
 
 ## What NOT to do
 
-- ❌ Do not add `obsidian-plugin-config` as a dependency in `templates/package.json` — injected plugins are standalone
-- ❌ Do not use `../obsidian-plugin-config/scripts/...` paths anywhere — that was the old sibling-repo approach, fully removed
 - ❌ Do not hardcode deps/scripts in `inject-core.ts` — they must come from `templates/package.json`
-- ❌ Do not modify root `tsconfig.json` or `package.json` to fix issues in injected plugins — fix `templates/` instead
-- ❌ Do not run `yarn upgrade` on root and expect it to update what gets injected — versions are defined in `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
 
 ---
 
-## obsidian-typings paths (current)
+## Updating injected content
 
-The correct paths for `obsidian-typings` in `tsconfig.json` (confirmed against installed `node_modules`):
+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"],
@@ -97,15 +118,4 @@ The correct paths for `obsidian-typings` in `tsconfig.json` (confirmed against i
 }
 ```
 
-These paths are in `templates/tsconfig.json` and must stay in sync with the actual `obsidian-typings` package structure.
-
----
-
-## docs/ folder
-
-- `docs/package-ex.json` — example of a real working injected plugin's `package.json` (reference only)
-- `docs/tsconfig-ex.json` — example of a real working injected plugin's `tsconfig.json` (reference only)
-- `docs/package-versions.json` — archive (reference only, source of truth is `templates/package.json`)
-- `docs/package-versions-sass.json` — archive (reference only, source of truth is `templates/package-sass.json`)
-- `docs/IMPROVEMENT-PLAN-FOR-LLM.md` — historical task list (may be outdated)
-- `docs/LLM-GUIDE.md` — this file
+These must stay in sync with the actual `obsidian-typings` package structure.

package/docs/TECHNICAL_NOTES.md

@@ -0,0 +1,43 @@
+# Notes Techniques
+
+## tslib
+
+**Qu'est-ce que c'est ?**
+`tslib` est une bibliothèque runtime pour TypeScript qui contient les helpers TypeScript (comme `__awaiter`, `__extends`, `__spreadArray`, etc.).
+
+**Pourquoi c'est important ?**
+Quand tu utilises `"importHelpers": true` dans `tsconfig.json`, TypeScript importe ces helpers depuis tslib au lieu de les dupliquer dans chaque fichier compilé. Ça réduit significativement la taille du bundle.
+
+**Exemple :**
+Sans tslib, chaque fichier async duplique le helper `__awaiter` (~200 bytes).
+Avec tslib, un seul import : `import { __awaiter } from "tslib"`.
+
+**Version :**
+On utilise `"tslib": "2.4.0"` (version stable, pas latest) pour éviter les breaking changes.
+
+## EditorConfig
+
+**Qu'est-ce que c'est ?**
+EditorConfig permet de définir des règles de formatage (indentation, line endings, etc.) qui fonctionnent dans tous les éditeurs.
+
+**Fichier injecté :**
+`.editorconfig` est automatiquement injecté dans le plugin.
+
+**Pour VSCode :**
+L'extension `editorconfig.editorconfig` doit être installée pour que VSCode respecte les règles.
+
+**Recommandations automatiques :**
+Le fichier `.vscode/extensions.json` suggère automatiquement les extensions nécessaires :
+- `esbenp.prettier-vscode` - Prettier
+- `dbaeumer.vscode-eslint` - ESLint
+- `editorconfig.editorconfig` - EditorConfig
+- `yzhang.markdown-all-in-one` - Markdown
+
+Quand l'utilisateur ouvre le projet, VSCode propose d'installer ces extensions.
+
+## Prettier vs EditorConfig
+
+**EditorConfig** : Règles de base (tabs/spaces, line endings, charset)
+**Prettier** : Formatage avancé du code (quotes, semicolons, line width, etc.)
+
+Les deux sont complémentaires. EditorConfig s'applique à tous les fichiers, Prettier se concentre sur le code.

package/docs/implementation_plan.md

@@ -0,0 +1,127 @@
+# Architecture Finale - Outil d'Injection Pur
+
+## ✅ Décisions Prises
+
+### 1. Suppression du développement local de plugin
+- **Avant** : Le projet servait à la fois d'outil d'injection ET de plugin local pour tester du code
+- **Après** : Outil d'injection pur, pas de développement local
+- **Raison** : Trop complexe pour les utilisateurs, dépendance inutile
+
+### 2. Suppression du système d'exports NPM
+- **Avant** : `src/` contenait du code exportable (modals, utils) via NPM
+- **Après** : Plus d'exports, uniquement injection de fichiers
+- **Raison** : Les utilisateurs préfèrent avoir le code directement dans leur plugin plutôt qu'une dépendance externe
+
+### 3. Workflow simplifié
+- **Avant** : Développement local → exports → injection
+- **Après** : Modification templates → publication NPM → injection globale
+- **Raison** : Un seul flux, plus simple à comprendre et maintenir
+
+## 🗑️ Fichiers Supprimés
+
+### Dossiers
+- `src/` - Code du plugin local et exports
+- `.vscode/` - Configuration VSCode (optionnel)
+
+### Fichiers racine
+- `manifest.json` - Manifeste du plugin Obsidian
+- `versions.json` - Versions du plugin
+- `.injection-info.json` - Métadonnées d'injection (pour plugins injectés uniquement)
+- `.env` - Chemins des vaults (plus nécessaire)
+- `CLEANUP.md` - Guide de nettoyage (obsolète après nettoyage)
+- `CHANGES.md` - Résumé des changements (obsolète)
+
+### Scripts
+- `scripts/esbuild.config.ts` - Build du plugin local
+- `scripts/sync-template-deps.ts` - Sync des dépendances
+- `scripts/update-exports.js` - Génération des exports
+
+### Documentation
+- `docs/EXPORTS-EXPLAINED.md` - Explication du système d'exports
+
+## 📦 Structure Finale
+
+```
+obsidian-plugin-config/
+├── bin/
+│   └── obsidian-inject.js          # CLI global (généré)
+├── docs/
+│   ├── LLM-GUIDE.md                # Guide pour LLM (mis à jour)
+│   └── implementation_plan.md      # Ce fichier
+├── scripts/
+│   ├── inject-core.ts              # Logique d'injection
+│   ├── inject-path.ts              # CLI avec flags
+│   ├── inject-prompt.ts            # CLI interactif
+│   ├── build-npm.ts                # Workflow de publication
+│   ├── acp.ts                      # Add, commit, push
+│   ├── help.ts                     # Aide
+│   ├── update-version-config.ts    # Bump de version
+│   └── utils.ts                    # Utilitaires
+├── templates/                      # SOURCE DE VÉRITÉ
+│   ├── scripts/                    # Scripts injectés
+│   ├── .github/workflows/          # GitHub Actions
+│   ├── package.json                # Config de base
+│   ├── package-sass.json           # Config SASS
+│   ├── tsconfig.json               # Config TypeScript
+│   ├── eslint.config.mts           # Config ESLint
+│   └── ...                         # Autres configs
+├── .npmignore                      # Exclusions NPM
+├── package.json                    # Config de l'outil
+├── tsconfig.json                   # Config TS (nettoyée)
+├── README.md                       # Documentation
+└── ...
+```
+
+## 🔄 Workflow de Développement
+
+### Modifier ce qui est injecté
+1. Éditer les fichiers dans `templates/`
+2. Tester localement : `yarn inject-path ../test-plugin`
+3. Publier : `yarn npm-publish`
+4. Installer globalement : `npm install -g obsidian-plugin-config@latest --force`
+
+### Utilisation globale
+```bash
+obsidian-inject                    # Dans le dossier du plugin
+obsidian-inject ../my-plugin       # Par chemin
+obsidian-inject ../my-plugin --sass # Avec SASS
+```
+
+## 🎯 Ce qui reste à faire
+
+### Nettoyage des dépendances
+```bash
+yarn remove obsidian obsidian-typings esbuild builtin-modules dotenv
+```
+
+### Vérification
+```bash
+yarn lint                          # Vérifier le code
+yarn inject-prompt                 # Tester l'injection
+```
+
+## 📝 Notes Importantes
+
+### Templates = Source de vérité
+- **JAMAIS** modifier les fichiers racine en pensant que ça affectera l'injection
+- **TOUJOURS** modifier `templates/` pour changer ce qui est injecté
+- Les scripts dans `scripts/` sont pour l'outil lui-même, pas pour l'injection
+
+### Pas de test local
+- Plus besoin de `.env` avec TEST_VAULT et REAL_VAULT
+- Plus de `yarn dev` ou `yarn real`
+- Tout passe par NPM global : modifier → publier → installer → tester
+
+### Plugins injectés = 100% autonomes
+- Aucune dépendance à `obsidian-plugin-config` après injection
+- Tous les scripts sont copiés localement
+- Mise à jour possible via ré-injection
+
+## 🚀 Prochaines Étapes
+
+1. ✅ Supprimer les fichiers obsolètes
+2. ✅ Nettoyer `tsconfig.json`
+3. ✅ Mettre à jour la documentation
+4. ⏳ Supprimer les dépendances inutiles
+5. ⏳ Tester l'injection
+6. ⏳ Publier la nouvelle version