obsidian-plugin-config 1.7.3 → 1.7.6

package/README.md

@@ -28,9 +28,9 @@ obsidian-inject
 # Prompts for confirmation before replacing each existing file
 obsidian-inject ../my-plugin
 
-# Inject without confirmation
-# Auto-confirms all file replacements (no prompts)
-obsidian-inject ../my-plugin --no
+# Inject without confirmation
+# Auto-confirms all file replacements (no prompts)
+obsidian-inject ../my-plugin --yes
 
 # Verification only (dry-run)
 # Shows what would be injected without making any changes
@@ -40,10 +40,10 @@ obsidian-inject ../my-plugin --dry-run
 obsidian-inject --help
 ```
 
-## CLI Options
-
-- `--no`, `-n` - Skip confirmation prompts (auto-confirm)
-- `--dry-run` - Verification only (no changes)
+## CLI Options
+
+- `--yes`, `-y` - Skip confirmation prompts (auto-confirm)
+- `--dry-run` - Verification only (no changes)
 
 ## What is injected
 

package/bin/obsidian-inject.js

@@ -3,13 +3,13 @@
 /**
  * Obsidian Plugin Config - CLI Entry Point
  * Global command: obsidian-inject
- * Version: 1.7.3
+ * Version: 1.7.6
  */
 
 import { execSync } from 'child_process';
 import { fileURLToPath } from 'url';
 import { dirname, join, isAbsolute, resolve } from 'path';
-import fs from 'fs';
+import { readFile, access, unlink, rm } from 'fs/promises';
 
 // Get the directory of this script
 const __filename = fileURLToPath(import.meta.url);
@@ -19,6 +19,15 @@ const packageRoot = dirname(__dirname);
 // Path to the injection script
 const injectScriptPath = join(packageRoot, 'scripts', 'inject-path.ts');
 
+async function pathExists(p) {
+  try {
+    await access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 function showHelp() {
   console.log(`
 Obsidian Plugin Config - Global CLI
@@ -56,7 +65,7 @@ More info: https://github.com/3C0D/obsidian-plugin-config
 `);
 }
 
-function main() {
+async function main() {
   const args = process.argv.slice(2);
 
   // Handle help flags
@@ -66,7 +75,7 @@ function main() {
   }
 
   // Check if injection script exists
-  if (!fs.existsSync(injectScriptPath)) {
+  if (!(await pathExists(injectScriptPath))) {
     console.error(`❌ Error: Injection script not found at ${injectScriptPath}`);
     console.error(`   Make sure obsidian-plugin-config is properly installed.`);
     process.exit(1);
@@ -94,14 +103,14 @@ function main() {
   try {
     // Check if target directory has package.json
     const targetPackageJson = join(targetPath, 'package.json');
-    if (!fs.existsSync(targetPackageJson)) {
+    if (!(await pathExists(targetPackageJson))) {
       console.error(`❌ Error: package.json not found in ${targetPath}`);
       console.error(`   Make sure this is a valid Node.js project.`);
       process.exit(1);
     }
 
     // Prevent injecting into obsidian-plugin-config itself
-    const pkg = JSON.parse(fs.readFileSync(targetPackageJson, 'utf8'));
+    const pkg = JSON.parse(await readFile(targetPackageJson, 'utf8'));
     if (pkg.name === 'obsidian-plugin-config') {
       console.error(`❌ Cannot inject into obsidian-plugin-config itself.`);
       process.exit(1);
@@ -109,25 +118,25 @@ function main() {
 
     // Clean NPM artifacts if package-lock.json exists
     const packageLockPath = join(targetPath, 'package-lock.json');
-    if (fs.existsSync(packageLockPath)) {
+    if (await pathExists(packageLockPath)) {
       console.log(`🧹 NPM installation detected, cleaning...`);
 
       try {
         // Remove package-lock.json
-        fs.unlinkSync(packageLockPath);
+        await unlink(packageLockPath);
         console.log(`   🗑️  package-lock.json removed`);
 
         // Remove node_modules if it exists
         const nodeModulesPath = join(targetPath, 'node_modules');
-        if (fs.existsSync(nodeModulesPath)) {
-          fs.rmSync(nodeModulesPath, { recursive: true, force: true });
+        if (await pathExists(nodeModulesPath)) {
+          await rm(nodeModulesPath, { recursive: true, force: true });
           console.log(`   🗑️  node_modules removed (will be reinstalled with Yarn)`);
         }
 
         console.log(`   ✅ NPM artifacts cleaned to avoid Yarn conflicts`);
 
       } catch (cleanError) {
-        console.error(`   ❌ Cleanup failed:`, cleanError.message);
+        console.error(`   ❌ Cleanup failed:`, cleanError instanceof Error ? cleanError.message : String(cleanError));
         console.log(`   💡 Manually remove package-lock.json and node_modules`);
       }
     }
@@ -174,5 +183,4 @@ function main() {
   }
 }
 
-// Run the CLI
-main();
+main().catch(console.error);

package/docs/INTERACTIVE_INJECTION.md

@@ -1,76 +1,67 @@
-# Injection interactive
+# Interactive Injection
 
-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.
+Injection is **interactive by default**: it compares each template file with the target's existing file and only prompts for confirmation when the content differs.
 
-## Points d'entrée
+## Entry Points
 
 ```bash
-# 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)
+# Global CLI
+obsidian-inject                 # Inject in current directory
+obsidian-inject ../my-plugin    # Inject by path
+
+# Local scripts (development of this repo)
+yarn inject-prompt              # Prompts for target plugin path, then injects
+yarn inject-path ../my-plugin   # Direct injection by path
+yarn check-plugin ../my-plugin  # Dry-run (verification only, no modifications)
 ```
 
-## Comportement fichier par fichier
+## File-by-File Behavior
 
-Pendant l'injection, chaque fichier est traité ainsi :
+During injection, each file is handled as follows:
 
-- **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 ...`).
+- **Target does not exist yet** → the file is injected without asking.
+- **Identical content** → silently ignored (`✅ ... (unchanged)`).
+- **Different content** → the tool asks `Update <file>? (content differs)`.
+  - `y` → the file is replaced.
+  - `n` → the existing file is kept (`⏭️ Kept existing ...`).
 
-Cas particuliers :
+Special cases:
 
-- `.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).
+- `.env` is always **merged**: the template is rewritten while preserving existing values (vault paths, etc.).
+- `.npmrc` is always injected (Yarn protection).
+- `eslint.config.mts` is automatically approved if an old `.eslintrc*` is detected (migration from the old format).
 
 ## Options
 
 ```bash
-# 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
+# Auto-confirm all replacements (no questions)
+obsidian-inject ../my-plugin --yes    # Global CLI: --yes / -y
+yarn inject-path ../my-plugin --yes   # Local scripts: --yes / -y
 
-# Vérification seule (n'écrit rien)
+# Verification only (writes nothing)
 obsidian-inject ../my-plugin --dry-run
 ```
 
-| 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            |
+| Option        | Effect                                         |
+| ------------- | ---------------------------------------------- |
+| `--yes`, `-y` | (Global CLI) auto-confirms all replacements    |
+| `--yes`, `-y` | (Local scripts) auto-confirms all replacements |
+| `--dry-run`   | Verification only, no modifications            |
 
-## Ce qui est injecté
+## What is Injected
 
-Tous les fichiers du template sont pris en compte à chaque injection (pas de
-sélection par composant) :
+All template files are considered during each injection (no component selection):
 
-- `templates/scripts/*` → `<cible>/scripts/`
-- `templates/tsconfig.json.template`, `eslint.config.mts`, `.editorconfig`,
-  `.prettierrc`, `.prettierignore`, `.npmrc`, `.env`
+- `templates/scripts/*` → `<target>/scripts/`
+- `templates/tsconfig.json.template`, `eslint.config.mts`, `.editorconfig`, `.prettierrc`, `.prettierignore`, `.npmrc`, `.env`
 - `templates/.vscode/*`
 - `templates/.github/workflows/*`
-- `templates/gitignore.template` → `<cible>/.gitignore`
+- `templates/gitignore.template` → `<target>/.gitignore`
 
-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.
+File-by-file confirmation allows keeping an existing file (for example, a custom `esbuild.config.ts`) by answering `n` when the prompt appears.
 
-## Fichiers concernés
+## Related Files
 
-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`).
+1. **scripts/inject-core.ts** — injection logic (`diffAndPromptFiles`, `injectScripts`, `updatePackageJson`, `performInjection`).
+2. **scripts/inject-prompt.ts** — interactive entry (prompts for path).
+3. **scripts/inject-path.ts** — CLI entry (parses `--yes`, `--dry-run`).

package/docs/SCSS-FLOW.md

@@ -1,47 +1,48 @@
-# Comment fonctionne SCSS dans cette config
+# How SCSS Works in this Config
 
-Ce document explique de bout en bout comment un fichier `.scss` est détecté, compilé puis copié dans le dossier `plugins` d'Obsidian, en s'appuyant sur le code du dépôt.
+This document explains end-to-end how a `.scss` file is detected, compiled, and then copied into the Obsidian `plugins` folder, based on the repository's code.
 
-> Remarque : la configuration SCSS n'est pas activée dans `obsidian-plugin-config` lui-même. Elle est définie dans les **templates** qui sont copiés dans chaque plugin Obsidian lors de l'injection (`yarn inject` / `obsidian-inject`). Tout le code cité ci-dessous vit donc dans `templates/scripts/`.
+> Note: SCSS configuration is not enabled in `obsidian-plugin-config` itself. It is defined in the **templates** that are copied into each Obsidian plugin during injection (`yarn inject` / `obsidian-inject`). All the code cited below resides in `templates/scripts/`.
 
 ---
 
-## 1. Vue d'ensemble du flux
+## 1. Flow Overview
 
 ```
 src/styles.scss
       │
-      │  détection (esbuild.config.ts → main())
+      │  detection (esbuild.config.ts → main())
       ▼
 entryPoints = [src/main.ts, src/styles.scss]
       │
       │  esbuild.context() + sassPlugin() (esbuild.config.ts → createBuildContext)
+      │  outbase: src/ → styles.scss → styles.css (name derived from entry, not main.ts)
       ▼
-buildPath/<id>/
+buildPath/
   ├── main.js
-  └── main.css        ← produit par esbuild-sass-plugin
+  └── styles.css      ← produced directly by esbuild+sassPlugin
       │
-      │  plugin "remove-main-css" (esbuild.config.ts) → utils.removeMainCss
-      │  + plugin "copy-to-plugins-folder" (esbuild.config.ts) → utils.copyFilesToTargetDir
+      │  plugin "rename-main-css" → utils.renameMainCss (no-op safety net: main.css does not exist)
+      │  plugin "copy-to-plugins-folder" → utils.copyFilesToTargetDir (manifest only if SCSS)
       ▼
-buildPath/<id>/
-  ├── manifest.json   (copié)
+buildPath/
+  ├── manifest.json   (copied)
   ├── main.js
-  └── styles.css      ← renommé depuis main.css ? non : voir point 3
+  └── styles.css      ← already in place, no renaming necessary
 ```
 
-Les deux moments clés sont :
+The two key moments are:
 
-1. **Détection et compilation** dans `templates/scripts/esbuild.config.ts`.
-2. **Nettoyage et copie vers le dossier plugins** via les fonctions utilitaires de `templates/scripts/utils.ts`.
+1. **Detection and compilation** in `templates/scripts/esbuild.config.ts`.
+2. **Cleanup and copying to the plugins folder** via utility functions in `templates/scripts/utils.ts`.
 
 ---
 
-## 2. Où passe le fichier SCSS
+## 2. SCSS File Path
 
-### 2.1 Détection du fichier SCSS
+### 2.1 SCSS File Detection
 
-Dans `templates/scripts/esbuild.config.ts`, fonction `main()` (lignes 115-140) :
+In `templates/scripts/esbuild.config.ts`, `main()` function:
 
 ```ts
 // Check for SCSS first, then CSS in src, then in root
@@ -63,40 +64,29 @@ const entryPoints = stylePath ? [mainTsPath, stylePath] : [mainTsPath];
 const context = await createBuildContext(buildPath, isProd, entryPoints, scssExists);
 ```
 
-- Le fichier SCSS est donc attendu à `src/styles.scss` (priorité maximale).
-- Sinon, fallback sur `src/styles.css` puis `styles.css` à la racine.
-- `scssExists` (booléen) sert ensuite à activer ou non le plugin SASS dans esbuild.
+- The SCSS file is expected at `src/styles.scss` (highest priority).
+- Otherwise, it falls back to `src/styles.css` then `styles.css` at the root.
+- `scssExists` (boolean) is then used to enable or disable the SASS plugin in esbuild.
 
 ### 2.2 Compilation via esbuild + sassPlugin
 
-Toujours dans `templates/scripts/esbuild.config.ts`, fonction `createBuildContext()` (lignes 33-69) :
+Also in `templates/scripts/esbuild.config.ts`, `createBuildContext()` function:
 
 ```ts
 const plugins = [
-  // Add SASS plugin if SCSS files are detected
   ...(hasSass
     ? [
         await (async () => {
-          try {
-            // @ts-expect-error - esbuild-sass-plugin is installed during injection
-            const { sassPlugin } = await import('esbuild-sass-plugin');
-            return sassPlugin({
-              syntax: 'scss',
-              style: 'expanded'
-            });
-          } catch (error) {
-            console.warn(
-              '⚠️  esbuild-sass-plugin not found. Install it with: yarn add -D esbuild-sass-plugin'
-            );
-            throw error;
-          }
+          // @ts-expect-error - esbuild-sass-plugin is installed during injection
+          const { sassPlugin } = await import('esbuild-sass-plugin');
+          return sassPlugin({ syntax: 'scss', style: 'expanded' });
         })(),
         {
-          name: 'remove-main-css',
+          name: 'rename-main-css',
           setup(build: esbuild.PluginBuild): void {
             build.onEnd(async (result) => {
               if (result.errors.length === 0) {
-                await removeMainCss(buildPath);
+                await renameMainCss(buildPath);
               }
             });
           }
@@ -105,48 +95,48 @@ const plugins = [
     : []),
 ```
 
-- Le `sassPlugin` n'est importé que si `hasSass` est `true` (donc si `src/styles.scss` existe).
-- Il est configuré en syntaxe `scss` et style `expanded` (non minifié, lisible).
-- esbuild produit un fichier `main.css` à côté de `main.js` dans `outdir` (= `buildPath`).
-- Un second plugin esbuild interne, `remove-main-css`, supprime ce `main.css` à la fin du build (voir 3.1).
+- The `sassPlugin` is only imported if `hasSass` is `true`.
+- It is configured with `scss` syntax and `expanded` style (not minified on the Sass side; esbuild applies its own minification if `isProd = true`).
+- **Output filename**: esbuild derives the name from the entry point. With `outbase: src/` and entry `src/styles.scss`, the relative path is `styles.scss` → output `buildPath/styles.css`. The name `main.ts` does not interfere.
+- The `rename-main-css` plugin is a **safety net**: in the current configuration, `buildPath/main.css` is never created, so `renameMainCss` is a no-op. It protects against future changes in sassPlugin behavior.
 
-### 2.3 Dépendance : `esbuild-sass-plugin`
+### 2.3 Dependency: `esbuild-sass-plugin`
 
-- Import dynamique, donc l'installation de la dépendance n'est pas obligatoire pour les plugins qui n'utilisent pas SCSS.
-- Le code affiche un warning et échoue si SCSS est détecté mais que le plugin n'est pas installé :
+Dynamic import: installation is not mandatory for plugins without SCSS. If SCSS is detected but the plugin is missing:
 
-  > `⚠️  esbuild-sass-plugin not found. Install it with: yarn add -D esbuild-sass-plugin`
+> `⚠️  esbuild-sass-plugin not found. Install it with: yarn add -D esbuild-sass-plugin`
 
-- Côté utilisateur, la doc le précise : `README.md`, section **SASS Support** (lignes 85-96).
+> **Note**: the `.sass` extension (indented syntax) is not supported. Only `.scss` is detected and compiled.
 
 ---
 
-## 3. Comment c'est copié dans le dossier plugins
+## 3. How it is Copied to the Plugins Folder
 
-### 3.1 Nettoyage du `main.css` parasite
+### 3.1 `renameMainCss` — Safety Net (no-op in current SCSS flow)
 
-Dans `templates/scripts/utils.ts`, fonction `removeMainCss()` (lignes 169-180) :
+In `templates/scripts/utils.ts`, `renameMainCss()` function:
 
 ```ts
-export async function removeMainCss(outdir: string): Promise<void> {
+export async function renameMainCss(outdir: string): Promise<void> {
   const mainCssPath = path.join(outdir, 'main.css');
+  const stylesCssPath = path.join(outdir, 'styles.css');
   try {
-    await rm(mainCssPath);
-  } catch (error: unknown) {
-    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
-      console.warn(
-        `Warning: Could not remove main.css: ${error instanceof Error ? error.message : String(error)}`
-      );
+    if (await isValidPath(mainCssPath)) {
+      await rename(mainCssPath, stylesCssPath);
     }
+  } catch (error: unknown) {
+    console.warn(`Warning: Could not rename main.css to styles.css: ...`);
   }
 }
 ```
 
-Pourquoi ? Le `sassPlugin` d'esbuild génère un fichier `main.css` parce qu'il hérite du `name` (`main`) de l'entry point. Or Obsidian attend `styles.css` dans le dossier du plugin. `removeMainCss` supprime donc ce fichier temporaire immédiatement après chaque build (uniquement si le build n'a pas d'erreur, cf. `if (result.errors.length === 0)` dans `esbuild.config.ts`).
+With `outbase: src/` and entry `src/styles.scss`, esbuild directly produces `buildPath/styles.css`. `buildPath/main.css` is therefore never created, and the `if (await isValidPath(mainCssPath))` check is always false. This function remains as a safeguard if sassPlugin behavior evolves.
+
+> **Context of `_.._`**: for the root CSS case (`styles.css` outside `outbase: src/`), esbuild encodes `../styles.css` as `_.._/styles.css`. This is not related to SCSS. `copyFilesToTargetDir` handles this case separately (manual copy + removal of `_.._/`).
 
-### 3.2 Copie vers le dossier plugins
+### 3.2 Copying to the Plugins Folder
 
-Dans `templates/scripts/utils.ts`, fonction `copyFilesToTargetDir()` (lignes 74-123) :
+In `templates/scripts/utils.ts`, `copyFilesToTargetDir()` function:
 
 ```ts
 export async function copyFilesToTargetDir(buildPath: string): Promise<void> {
@@ -176,11 +166,11 @@ export async function copyFilesToTargetDir(buildPath: string): Promise<void> {
 }
 ```
 
-> Note importante : `copyFilesToTargetDir` ne copie **que** `manifest.json` et un éventuel `styles.css` / `styles.css` racine. Le `main.css` généré par esbuild-sass-plugin est supprimé à l'étape précédente (3.1).
+> Important Note: `copyFilesToTargetDir` only copies `manifest.json` and any potential `styles.css` at the root. The `main.css` generated by esbuild-sass-plugin is renamed to `styles.css` in the previous step (3.1).
 
-### 3.3 Branchement sur le cycle de vie esbuild
+### 3.3 Integration into the esbuild Lifecycle
 
-Toujours dans `templates/scripts/esbuild.config.ts`, le plugin `copy-to-plugins-folder` (lignes 70-94) déclenche la copie après chaque build :
+Also in `templates/scripts/esbuild.config.ts`, the `copy-to-plugins-folder` plugin triggers copying after each build:
 
 ```ts
 {
@@ -208,30 +198,30 @@ Toujours dans `templates/scripts/esbuild.config.ts`, le plugin `copy-to-plugins-
 }
 ```
 
-- Mode **dev (`yarn dev`)** : après chaque rebuild (watch), `copyFilesToTargetDir` recopie manifest + CSS vers le vault de test.
-- Mode **build prod (`yarn build`)** : rien n'est copié par défaut, sauf si on passe `-r` / `real` (=> copie vers le vault de prod + reload Obsidian).
+- **Dev mode (`yarn dev`)**: after each rebuild (watch), `copyFilesToTargetDir` recopies the manifest + CSS to the test vault.
+- **Prod build mode (`yarn build`)**: nothing is copied by default, unless `-r` / `real` is passed (=> copy to production vault + reload Obsidian).
 
-### 3.4 Cible : `buildPath`
+### 3.4 Target: `buildPath`
 
-`buildPath` est calculé par `env.ts` (`getBuildPath`) à partir de `.env` (`TEST_VAULT` / `REAL_VAULT`) ou du dossier courant (développement in-place). Il pointe vers :
+`buildPath` is calculated by `env.ts` (`getBuildPath`) from `.env` (`TEST_VAULT` / `REAL_VAULT`) or the current directory (in-place development). It points to:
 
 ```
 <vault>/.obsidian/plugins/<pluginId>/
 ```
 
-Donc concrètement, le résultat final pour le SCSS est :
+So concretely, the final result for SCSS is:
 
-1. `src/styles.scss` → compilé par esbuild-sass-plugin → `buildPath/main.css` (transitoire)
-2. `main.css` renommé en `styles.css` par `renameMainCss`
-3. Le CSS est directement disponible et référencé via `manifest.json` (`"css": "styles.css"`).
+1. `src/styles.scss` → compiled by esbuild-sass-plugin → `buildPath/main.css` (transient)
+2. `main.css` renamed to `styles.css` by `renameMainCss`
+3. The CSS is directly available and referenced via `manifest.json` (`"css": "styles.css"`).
 
-> 💡 Le `styles.css` final est produit automatiquement par ce pipeline en renommant le fichier `main.css` issu de la compilation SCSS. Aucun fichier source `styles.css` n'est nécessaire à la racine si vous utilisez exclusivement du SCSS.
+> 💡 The final `styles.css` is automatically produced by this pipeline by renaming the `main.css` file from the SCSS compilation. No root `styles.css` source file is necessary if you use SCSS exclusively.
 
 ---
 
-## 4. Où l'injecteur installe tout ça dans le plugin cible
+## 4. Where the Injector Installs Everything in the Target Plugin
 
-L'injection des templates se fait dans `scripts/inject-core.ts`, fonction `injectScripts()` (lignes 455-612). Le tableau `scriptFiles` (lignes 469-480) liste explicitement les fichiers copiés dans le dossier `scripts/` du plugin cible :
+Template injection happens in `scripts/inject-core.ts`, `injectScripts()` function. The `scriptFiles` array explicitly lists files copied into the target plugin's `scripts/` folder:
 
 ```ts
 const scriptFiles = [
@@ -248,9 +238,9 @@ const scriptFiles = [
 ];
 ```
 
-Donc après injection, le plugin Obsidian cible contient `scripts/esbuild.config.ts` (avec la logique SCSS) et `scripts/utils.ts` (avec `removeMainCss` et `copyFilesToTargetDir`).
+So after injection, the target Obsidian plugin contains `scripts/esbuild.config.ts` (with SCSS logic) and `scripts/utils.ts` (with `renameMainCss` and `copyFilesToTargetDir`).
 
-Le `.gitignore` injecté (`templates/gitignore.template`, ligne 25-26) ignore explicitement le fichier intermédiaire :
+The injected `.gitignore` (`templates/gitignore.template`) explicitly ignores the intermediate file:
 
 ```
 # scss result
@@ -259,15 +249,29 @@ main.css
 
 ---
 
-## 5. Récapitulatif des fichiers clés
-
-| Rôle | Fichier | Fonctions / lignes |
-|------|---------|--------------------|
-| Détection SCSS + build esbuild | `templates/scripts/esbuild.config.ts` | `main()` ~l. 115-140, `createBuildContext()` ~l. 33-69 |
-| Plugin esbuild pour compiler SCSS | `esbuild-sass-plugin` (importé dynamiquement) | `esbuild.config.ts` ~l. 41-58 |
-| Suppression du `main.css` transitoire | `templates/scripts/utils.ts` | `removeMainCss()` ~l. 169-180 |
-| Copie finale vers le dossier plugins | `templates/scripts/utils.ts` | `copyFilesToTargetDir()` ~l. 74-123 |
-| Branchement sur `onEnd` esbuild | `templates/scripts/esbuild.config.ts` | plugin `copy-to-plugins-folder` ~l. 70-94 |
-| Copie des templates vers le plugin cible | `scripts/inject-core.ts` | `injectScripts()` ~l. 455-612, `buildFileList()` ~l. 284-353 |
-| Dépendance optionnelle | `esbuild-sass-plugin` (ajoutée par l'utilisateur si SCSS) | `README.md` § SASS Support, ~l. 85-96 |
-| Ignore du fichier transitoire | `templates/gitignore.template` | `main.css` ligne 25-26 |
+## 5. Key Files Summary
+
+| Role                                                                 | File                                          | Functions / Lines                    |
+| -------------------------------------------------------------------- | --------------------------------------------- | ------------------------------------ |
+| SCSS detection + esbuild build                                       | `templates/scripts/esbuild.config.ts`         | `main()`, `createBuildContext()`     |
+| esbuild plugin to compile SCSS                                       | `esbuild-sass-plugin` (dynamically imported)  | `esbuild.config.ts`                  |
+| Safety net (no-op SCSS): rename `main.css` → `styles.css` if present | `templates/scripts/utils.ts`                  | `renameMainCss()`                    |
+| Final copy to plugins folder                                         | `templates/scripts/utils.ts`                  | `copyFilesToTargetDir()`             |
+| Hook into esbuild `onEnd`                                            | `templates/scripts/esbuild.config.ts`         | `copy-to-plugins-folder` plugin      |
+| Copy templates to target plugin                                      | `scripts/inject-core.ts`                      | `injectScripts()`, `buildFileList()` |
+| Optional dependency                                                  | `esbuild-sass-plugin` (added by user if SCSS) | `README.md` § SASS Support           |
+| Ignore transient file                                                | `templates/gitignore.template`                | `main.css`                           |
+
+---
+
+## 6. Scenario Coverage
+
+| Scenario                             | `buildPath`                       | CSS produced by esbuild | In place after build? |
+| ------------------------------------ | --------------------------------- | ----------------------- | --------------------- |
+| Watch, in-place (pluginDir in vault) | `pluginDir`                       | `pluginDir/styles.css`  | ✅ direct              |
+| Watch, external → TEST_VAULT         | `<vault>/.obsidian/plugins/<id>/` | `buildPath/styles.css`  | ✅ direct              |
+| Prod + `-r`, external → REAL_VAULT   | `<vault>/.obsidian/plugins/<id>/` | `buildPath/styles.css`  | ✅ direct              |
+| Prod, initial folder (`yarn build`)  | `pluginDir`                       | `pluginDir/styles.css`  | ✅ direct              |
+| Release (GH Actions, `yarn build`)   | `pluginDir` (no vault)            | `pluginDir/styles.css`  | ✅ direct              |
+
+In all SCSS scenarios, `copyFilesToTargetDir` does not find a source CSS file (`src/styles.css` absent, no root `styles.css`) and returns early — the CSS is already in `buildPath` directly produced by esbuild. Only `manifest.json` is copied by this function in the SCSS case.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-plugin-config",
-  "version": "1.7.3",
+  "version": "1.7.6",
   "description": "Global CLI injection tool for Obsidian plugins",
   "type": "module",
   "bin": {

package/scripts/acp.ts

@@ -1,22 +1,23 @@
-import { execSync, spawnSync } from 'child_process';
-import fs from 'fs';
+import { readFile } from 'fs/promises';
 import path from 'path';
 import {
   askQuestion,
   cleanInput,
   createReadlineInterface,
   gitExec,
-  ensureGitSync
+  gitOutput,
+  ensureGitSync,
+  isValidPath
 } from './utils.js';
 
 const rl = createReadlineInterface();
 
 /** Check if we're in the centralized config repo */
-function isInCentralizedRepo(): boolean {
+async function isInCentralizedRepo(): Promise<boolean> {
   const packageJsonPath = path.join(process.cwd(), 'package.json');
-  if (!fs.existsSync(packageJsonPath)) return false;
+  if (!(await isValidPath(packageJsonPath))) return false;
 
-  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf8'));
   return packageJson.name === 'obsidian-plugin-config';
 }
 
@@ -25,7 +26,7 @@ async function main(): Promise<void> {
     if (process.argv.includes('-b')) {
       console.log('Building...');
       // For obsidian-plugin-config, just run TypeScript check
-      if (isInCentralizedRepo()) {
+      if (await isInCentralizedRepo()) {
         gitExec('npx tsc --noEmit');
       } else {
         gitExec('yarn build');
@@ -39,17 +40,14 @@ async function main(): Promise<void> {
 
     try {
       gitExec('git add -A');
-      const result = spawnSync('git', ['commit', '-m', cleanedInput], { stdio: 'inherit' });
-      if (result.status !== 0) {
-        throw new Error('Commit failed');
-      }
+      gitExec(`git commit -m "${cleanedInput}"`);
     } catch {
       console.log('Commit already exists or failed.');
       return;
     }
 
     // get current branch name
-    const currentBranch = execSync('git rev-parse --abbrev-ref HEAD').toString().trim();
+    const currentBranch = gitOutput('git rev-parse --abbrev-ref HEAD');
 
     // Ensure Git is synchronized before pushing
     await ensureGitSync();