obsidian-plugin-config 1.0.5 → 1.1.0

package/README.md

@@ -1,7 +1,14 @@
 # Obsidian Plugin Config
 
+<!-- Test modification pour vérifier auto-commit -->
+
 🎯 Système d'injection pour plugins Obsidian autonomes.
 
+[![NPM Version](https://img.shields.io/npm/v/obsidian-plugin-config)](https://www.npmjs.com/package/obsidian-plugin-config)
+[![License](https://img.shields.io/npm/l/obsidian-plugin-config)](LICENSE)
+
+**Version actuelle : 1.0.6**
+
 ## Installation Globale
 
 ```bash
@@ -24,6 +31,14 @@ obsidian-inject ../mon-plugin
 obsidian-inject "C:\chemin\vers\plugin"
 ```
 
+### Vérification (sans injection)
+
+```bash
+# Vérifier si un plugin est déjà injecté (avec info de version)
+yarn check-plugin ../mon-plugin
+yarn verify-plugin ../mon-plugin  # alias
+```
+
 ### Aide
 
 ```bash
@@ -33,10 +48,41 @@ obsidian-inject --help
 ## Ce qui est injecté
 
 - ✅ **Scripts locaux autonomes** : `esbuild.config.ts`, `acp.ts`, `update-version.ts`, `utils.ts`, `help.ts`, `release.ts`
-- ✅ **Configuration package.json** : scripts, dépendances, protection yarn obligatoire
-- ✅ **Template tsconfig.json** : configuration TypeScript optimisée
+- ✅ **Configuration package.json** : scripts, dépendances, protection yarn obligatoire, `"type": "module"` pour ESM
+- ✅ **Template tsconfig.json** : configuration TypeScript moderne optimisée
 - ✅ **Installation automatique** des dépendances avec yarn
 - ✅ **Analyse des imports centralisés** avec avertissements
+- ✅ **Fichier de traçabilité** : `.injection-info.json` (version, date d'injection)
+
+## 📋 Suivi des versions d'injection
+
+Le système crée un fichier `.injection-info.json` dans chaque plugin injecté pour tracer :
+
+- **Version de l'injecteur** utilisée
+- **Date d'injection**
+- **Nom de l'injecteur** (`obsidian-plugin-config`)
+
+> ⚠️ **Important** : Le fichier `.injection-info.json` est **commité avec le plugin** pour assurer la traçabilité sur GitHub et permettre de voir facilement qu'un plugin a été injecté et avec quelle version.
+
+### Statuts possibles lors de la vérification
+
+- ✅ **Plugin injecté** : Affiche version, date et détecte les mises à jour disponibles
+- ⚠️ **Plugin injecté (legacy)** : Injecté avec l'ancien système, re-injection recommandée
+- ❌ **Plugin non injecté** : Aucune injection détectée
+
+## ⚠️ Configuration ESM Moderne
+
+Le système utilise une configuration TypeScript moderne avec ESM. Si votre plugin a des imports relatifs, vous devrez peut-être les corriger :
+
+```typescript
+// ❌ Ancien format
+import { helper } from "./MyHelper";
+
+// ✅ Format ESM requis
+import { helper } from "./MyHelper.js";
+```
+
+Cette correction est nécessaire une seule fois après l'injection.
 
 ## Commandes disponibles après injection
 
@@ -67,15 +113,45 @@ Le plugin devient **100% AUTONOME** après injection :
 
 ## Développement Local (pour contributeurs)
 
+### Installation
+
 ```bash
 git clone https://github.com/3C0D/obsidian-plugin-config
 cd obsidian-plugin-config
 yarn install
+```
 
-# Test injection locale
+### Test injection locale
+
+```bash
+# Injection automatique
 yarn inject ../mon-plugin --yes
+
+# Injection avec prompts
 yarn inject-prompt "../mon-plugin"
+```
 
-# Build package NPM
+### Workflow complet : Local → NPM
+
+```bash
+# 1. Développement local
+yarn inject ../test-plugin --yes
+
+# 2. Corriger imports ESM si nécessaire
+# Exemple: "./utils.ts" → "./utils.js"
+
+# 3. Build et publication NPM
 yarn build-npm
+yarn update-version
+npm login
+npm publish
+```
+
+### Commandes de maintenance
+
+```bash
+yarn acp                # Add, commit, push
+yarn update-version     # Mise à jour version
+yarn build-npm         # Build package NPM
+yarn help              # Aide complète
 ```

package/docs/injection-strategy-analysis.md

@@ -0,0 +1,277 @@
+# Analyse des Stratégies d'Injection - Plugins Obsidian
+
+## Vue d'ensemble
+
+Ce document analyse les différentes approches d'injection de code et de configuration pour les plugins Obsidian, en comparant notre système actuel avec les solutions existantes.
+
+## 1. Notre Approche Actuelle (obsidian-plugin-config)
+
+### Stratégie : Injection Dure + Package NPM
+
+**Principe :**
+
+- **Injection locale** : Copie physique des fichiers depuis `templates/` vers le plugin cible
+- **Package NPM global** : `obsidian-inject` pour injection depuis n'importe où
+- **Autonomie complète** : Aucune dépendance externe après injection
+
+**Architecture :**
+
+```
+obsidian-plugin-config/
+├── templates/           # Templates à injecter
+│   ├── scripts/        # Scripts de build/dev
+│   ├── eslint.config.mts
+│   └── tsconfig-template.json
+├── src/                # Modules réutilisables (actuels)
+│   ├── modals/         # GenericConfirmModal
+│   ├── utils/          # NoticeHelper, SettingsHelper
+│   └── tools/          # (vide actuellement)
+└── scripts/            # Scripts d'injection
+    ├── inject-path.ts
+    └── inject-prompt.ts
+```
+
+**Avantages :**
+
+- ✅ Autonomie totale après injection
+- ✅ Pas de dépendances externes
+- ✅ Contrôle total sur les versions
+- ✅ Fonctionne offline
+
+**Inconvénients :**
+
+- ❌ Duplication de code entre plugins
+- ❌ Mise à jour manuelle (re-injection)
+- ❌ Modules src/ non utilisés (injection dure uniquement)
+
+## 2. Approche mnaoumov
+
+### Stratégie : Generator + Package NPM + Imports
+
+**Architecture :**
+
+1. **generator-obsidian-plugin** : Yeoman generator pour créer des plugins
+2. **obsidian-dev-utils** : Package NPM avec utilitaires importables
+3. **obsidian-sample-plugin-extended** : Template de référence
+
+**Principe :**
+
+```javascript
+// Dans le plugin généré
+import { someHelper } from "obsidian-dev-utils";
+```
+
+**Package obsidian-dev-utils :**
+
+- CLI commands (build, lint, etc.)
+- Helper functions (importables)
+- Setting components
+- Modals
+- Debugging tools
+
+**Avantages :**
+
+- ✅ Mise à jour automatique via NPM
+- ✅ Pas de duplication de code
+- ✅ Écosystème riche (Svelte, React, SASS)
+- ✅ Maintenance centralisée
+
+**Inconvénients :**
+
+- ❌ Dépendance externe permanente
+- ❌ Risque de breaking changes
+- ❌ Nécessite connexion pour updates
+
+## 3. Approche Officielle (obsidian-sample-plugin)
+
+### Stratégie : Template Simple
+
+**Principe :**
+
+- Template minimal fourni par Obsidian
+- Fork/clone + modification manuelle
+- Aucun système d'injection
+
+**Avantages :**
+
+- ✅ Simplicité maximale
+- ✅ Contrôle total
+
+**Inconvénients :**
+
+- ❌ Pas de réutilisabilité
+- ❌ Maintenance manuelle
+- ❌ Pas d'évolution
+
+## 4. Comparaison des Stratégies
+
+| Aspect              | Notre Approche      | mnaoumov         | Officiel |
+| ------------------- | ------------------- | ---------------- | -------- |
+| **Réutilisabilité** | Moyenne (templates) | Élevée (imports) | Faible   |
+| **Autonomie**       | Totale              | Dépendante       | Totale   |
+| **Maintenance**     | Manuelle            | Automatique      | Manuelle |
+| **Complexité**      | Moyenne             | Élevée           | Faible   |
+| **Évolutivité**     | Bonne               | Excellente       | Limitée  |
+
+## 5. Problématique Actuelle
+
+### Modules src/ Non Exploités
+
+Nous avons des modules dans `src/` (modals, utils) mais ils ne sont pas utilisés car :
+
+- L'injection est "dure" (copie de fichiers)
+- Pas d'imports depuis le package NPM
+- Système d'exports automatique non exploité
+
+### Questions Stratégiques
+
+1. **Faut-il passer aux imports NPM ?**
+
+   - Avantages : Réutilisabilité, maintenance centralisée
+   - Inconvénients : Dépendance externe, complexité
+
+2. **Faut-il garder l'injection dure ?**
+
+   - Avantages : Autonomie, simplicité
+   - Inconvénients : Duplication, maintenance manuelle
+
+3. **Approche hybride possible ?**
+   - Templates pour la structure (injection dure)
+   - Modules pour le code réutilisable (imports NPM)
+
+## 6. Recommandations Stratégiques
+
+### Option A : Hybride (Recommandée)
+
+- **Templates** : Scripts, configuration (injection dure)
+- **Modules** : Composants réutilisables (imports NPM)
+- **Avantage** : Meilleur des deux mondes
+
+### Option B : Full NPM (comme mnaoumov)
+
+- Tout en imports NPM
+- Dépendance externe acceptée
+- Maintenance centralisée
+
+### Option C : Full Injection (actuel)
+
+- Tout en injection dure
+- Déplacer src/ vers templates/
+- Autonomie maximale
+
+## 7. Découvertes de l'Historique
+
+### Ancienne Approche (Trouvée dans obsidian-sample-plugin-modif)
+
+**Imports NPM découverts :**
+
+```javascript
+// Dans src/test-centralized-utils.ts (commenté)
+import { NoticeHelper } from "obsidian-plugin-config/utils";
+```
+
+**Configuration package.json (ancienne) :**
+
+```json
+{
+  "dependencies": {
+    "obsidian-plugin-config": "file:../obsidian-plugin-config"
+  }
+}
+```
+
+**Exports dans obsidian-plugin-config :**
+
+```json
+{
+  "exports": {
+    "./modals": "./src/modals/index.ts",
+    "./utils": "./src/utils/index.ts",
+    "./tools": "./src/tools/index.ts"
+  }
+}
+```
+
+### Transition Observée
+
+1. **Avant** : Imports NPM depuis obsidian-plugin-config
+2. **Maintenant** : Injection dure + modules copiés localement
+3. **Résultat** : Duplication des modules (src/ dans les deux repos)
+
+### Pattern d'Utilisation Identifié
+
+```javascript
+// Utilisation typique (avant)
+import { NoticeHelper } from "obsidian-plugin-config/utils";
+import { GenericConfirmModal } from "obsidian-plugin-config/modals";
+
+// Dans le plugin
+NoticeHelper.success("✅ Action réussie !");
+new GenericConfirmModal(this.app, options).open();
+```
+
+## 8. Prochaines Étapes
+
+1. ✅ **Analyser l'historique** - FAIT : Trouvé les anciens imports NPM
+2. **Décider de la stratégie** : Hybride vs Full NPM vs Full Injection
+3. **Tester l'approche choisie** sur un plugin pilote
+4. **Implémenter la solution finale**
+
+### Recommandation Mise à Jour
+
+**Option A : Retour aux Imports NPM (Recommandée)**
+
+- Réactiver les exports dans package.json
+- Permettre `import { NoticeHelper } from "obsidian-plugin-config/utils"`
+- Garder l'injection dure pour les scripts/config
+- **Avantage** : Pas de duplication, maintenance centralisée
+
+## 9. État Actuel (Mise à Jour)
+
+### ✅ Découvertes Positives
+
+**Infrastructure déjà en place :**
+
+- ✅ Exports configurés dans package.json
+- ✅ Script update-exports.js fonctionnel
+- ✅ Modules src/ complets (modals, utils, tools)
+- ✅ Index.ts auto-généré
+
+**Test réussi sur test-sample-plugin :**
+
+```javascript
+// Imports fonctionnels
+import { NoticeHelper } from "obsidian-plugin-config/utils";
+import { GenericConfirmModal } from "obsidian-plugin-config/modals";
+
+// Configuration package.json
+"obsidian-plugin-config": "file:../obsidian-plugin-config"
+```
+
+### 🎯 Prochaines Étapes Immédiates
+
+1. ✅ **Test local** - FAIT : Imports fonctionnent en local
+2. **Test NPM** - Publier version avec exports et tester
+3. **Migration plugins existants** - Ajouter imports aux plugins actuels
+4. **Documentation** - Documenter l'usage hybride
+
+### 🔄 Workflow Recommandé
+
+**Phase 1 : Test Local (En Cours)**
+
+- Injection dure + dépendance locale `file:../obsidian-plugin-config`
+- Validation des imports sur plugins de test
+
+**Phase 2 : Package NPM**
+
+- Publier obsidian-plugin-config avec exports
+- Tester `obsidian-inject` + imports NPM
+
+**Phase 3 : Migration**
+
+- Migrer plugins existants vers approche hybride
+- Documentation complète
+
+---
+
+_Document créé pour clarifier la stratégie d'injection d'obsidian-plugin-config_

package/eslint.config.mts

@@ -0,0 +1,54 @@
+import * as typescriptEslintParser from "@typescript-eslint/parser";
+import typescriptEslintPlugin from "@typescript-eslint/eslint-plugin";
+import "eslint-import-resolver-typescript";
+import type {
+  Linter
+} from "eslint";
+
+const configs: Linter.Config[] = [
+  {
+    ignores: [
+      "eslint.config.mts",
+      "templates/**"
+    ]
+  },
+  {
+    files: ["**/*.ts"],
+    ignores: [
+      "dist/**",
+      "node_modules/**",
+      "main.js"
+    ],
+    languageOptions: {
+      parser: typescriptEslintParser,
+      sourceType: "module",
+      parserOptions: {
+        project: "./tsconfig.json",
+        ecmaVersion: 2023
+      }
+    },
+    plugins: {
+      "@typescript-eslint": typescriptEslintPlugin as any // Type assertion to bypass type checking
+    },
+    rules: {
+      // Base rules
+      "no-unused-vars": "off",
+      "@typescript-eslint/no-unused-vars": ["warn", { "args": "none" }],
+      "@typescript-eslint/ban-ts-comment": "off",
+      "no-prototype-builtins": "off",
+      "@typescript-eslint/no-empty-function": "off",
+
+      // Useful rules but not too strict
+      "semi": "error",
+      "@typescript-eslint/explicit-function-return-type": "warn",
+
+      // Disable overly strict rules
+      "@typescript-eslint/no-unsafe-assignment": "off",
+      "@typescript-eslint/no-unsafe-call": "off",
+      "@typescript-eslint/no-unsafe-member-access": "off",
+      "@typescript-eslint/no-unsafe-argument": "off"
+    }
+  }
+];
+
+export default configs;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "obsidian-plugin-config",
-	"version": "1.0.5",
+	"version": "1.1.0",
 	"description": "Système d'injection pour plugins Obsidian autonomes",
 	"type": "module",
 	"main": "src/index.ts",
@@ -27,10 +27,13 @@
 		"inject-path": "tsx scripts/inject-path.ts",
 		"inject": "tsx scripts/inject-path.ts",
 		"inject-prompt": "tsx scripts/inject-prompt.ts",
+		"check-plugin": "tsx scripts/inject-path.ts --dry-run",
 		"build-npm": "tsx scripts/build-npm.ts",
 		"publish-npm": "tsx scripts/build-npm.ts",
 		"help": "tsx scripts/help.ts",
 		"h": "tsx scripts/help.ts",
+		"lint": "eslint . --ext .ts",
+		"lint:fix": "eslint . --ext .ts --fix",
 		"dev": "tsx scripts/esbuild.config.ts",
 		"build": "tsc -noEmit -skipLibCheck",
 		"real": "tsx scripts/esbuild.config.ts production real",
@@ -46,13 +49,19 @@
 		"./utils": "./src/utils/index.ts"
 	},
 	"devDependencies": {
+		"@types/eslint": "latest",
 		"@types/node": "^22.15.26",
 		"@types/semver": "^7.7.0",
+		"@typescript-eslint/eslint-plugin": "latest",
+		"@typescript-eslint/parser": "latest",
 		"builtin-modules": "3.3.0",
 		"dedent": "^1.6.0",
 		"dotenv": "^16.4.5",
 		"esbuild": "latest",
+		"eslint": "latest",
+		"eslint-import-resolver-typescript": "latest",
 		"fs-extra": "^11.2.0",
+		"jiti": "latest",
 		"obsidian": "*",
 		"obsidian-typings": "^3.9.5",
 		"semver": "^7.7.2",

package/scripts/acp.ts

@@ -5,7 +5,8 @@ import {
   askQuestion,
   cleanInput,
   createReadlineInterface,
-  gitExec
+  gitExec,
+  ensureGitSync
 } from "./utils.js";
 
 const rl = createReadlineInterface();
@@ -49,6 +50,9 @@ async function main(): Promise<void> {
     // get current branch name
     const currentBranch = execSync("git rev-parse --abbrev-ref HEAD").toString().trim();
 
+    // Ensure Git is synchronized before pushing
+    await ensureGitSync();
+
     try {
       gitExec(`git push origin ${currentBranch}`);
       console.log("Commit and push successful.");

package/scripts/build-npm.ts

@@ -1,10 +1,8 @@
 #!/usr/bin/env tsx
 
 import fs from "fs";
-import path from "path";
 import { execSync } from "child_process";
 import {
-  askQuestion,
   askConfirmation,
   createReadlineInterface
 } from "./utils.js";
@@ -20,10 +18,10 @@ async function buildNpmPackage(): Promise<void> {
   try {
     // Step 1: Verify all scripts are ready
     console.log(`\n📋 Verifying scripts...`);
-    
+
     const requiredScripts = [
       "scripts/inject-path.ts",
-      "scripts/inject-prompt.ts", 
+      "scripts/inject-prompt.ts",
       "scripts/utils.ts",
       "scripts/esbuild.config.ts",
       "scripts/acp.ts",
@@ -42,7 +40,7 @@ async function buildNpmPackage(): Promise<void> {
     // Step 2: Update bin/obsidian-inject.js if needed
     console.log(`\n📦 Checking bin/obsidian-inject.js...`);
     const binPath = "bin/obsidian-inject.js";
-    
+
     if (fs.existsSync(binPath)) {
       console.log(`   ✅ ${binPath} exists`);
     } else {
@@ -52,7 +50,7 @@ async function buildNpmPackage(): Promise<void> {
     // Step 3: Verify package.json is ready for NPM
     console.log(`\n📄 Verifying package.json for NPM...`);
     const packageJson = JSON.parse(fs.readFileSync("package.json", "utf8"));
-    
+
     const requiredFields = {
       name: packageJson.name,
       version: packageJson.version,
@@ -74,7 +72,7 @@ async function buildNpmPackage(): Promise<void> {
     try {
       const whoami = execSync('npm whoami', { encoding: 'utf8' }).trim();
       console.log(`   ✅ Logged in as: ${whoami}`);
-    } catch (error) {
+    } catch {
       console.log(`   ❌ Not logged into NPM`);
       console.log(`   💡 Run: npm login`);
       throw new Error("NPM authentication required");
@@ -85,15 +83,15 @@ async function buildNpmPackage(): Promise<void> {
     try {
       execSync('yarn build', { stdio: 'inherit' });
       console.log(`   ✅ Build test passed`);
-    } catch (error) {
+    } catch {
       throw new Error("Build test failed");
     }
 
     console.log(`\n✅ Package is ready for NPM publication!`);
-    
+
     // Step 6: Ask for confirmation
     const shouldPublish = await askConfirmation(`\nProceed with NPM publication?`, rl);
-    
+
     if (!shouldPublish) {
       console.log(`❌ Publication cancelled`);
       return;
@@ -102,7 +100,7 @@ async function buildNpmPackage(): Promise<void> {
     // Step 7: Publish to NPM
     console.log(`\n📤 Publishing to NPM...`);
     execSync('npm publish', { stdio: 'inherit' });
-    
+
     console.log(`\n🎉 Package published successfully!`);
     console.log(`\n📋 Next steps:`);
     console.log(`   1. npm install -g ${packageJson.name}`);