obsidian-plugin-config 1.7.2 → 1.7.5

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.2
+ * Version: 1.7.5
  */
 
 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`, `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/LLM-GUIDE.md

@@ -13,8 +13,8 @@
 `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/package.json.template` — base deps/scripts merged into `<target>/package.json`
+- `templates/tsconfig.json.template` — 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
@@ -37,7 +37,7 @@
 
 ### 1. Package.json merge
 
-`inject-core.ts → updatePackageJson()` reads `templates/package.json` and merges into the target plugin's `package.json`:
+`inject-core.ts → updatePackageJson()` reads `templates/package.json.template` and merges into the target plugin's `package.json`:
 
 - All `scripts` are overwritten with template values
 - All `devDependencies` from template are added/updated
@@ -51,7 +51,8 @@
 - `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/.editorconfig`, `.prettierrc`, `.npmrc`, `.env`, `.gitattributes` → `<target>/`
+- `templates/.vscode/*` → `<target>/.vscode/`
 - `templates/.github/workflows/*` → `<target>/.github/workflows/`
 - `templates/gitignore.template` → `<target>/.gitignore`
 
@@ -95,9 +96,9 @@ The `esbuild-sass-plugin` dependency is **not** injected automatically. If a plu
 
 ## What NOT to do
 
-- ❌ Do not hardcode deps/scripts in `inject-core.ts` — they must come from `templates/package.json`
+- ❌ Do not hardcode deps/scripts in `inject-core.ts` — they must come from `templates/package.json.template`
 - ❌ 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 add `obsidian-plugin-config` as a dependency in `templates/package.json.template` — 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
 
 ---
@@ -115,7 +116,7 @@ To change what gets injected:
 
 ## obsidian-typings paths
 
-The correct paths for `obsidian-typings` in `templates/tsconfig.json`:
+The correct paths for `obsidian-typings` in `templates/tsconfig.json.template`:
 
 ```json
 "types": ["obsidian-typings"],

package/docs/SCSS-FLOW.md

@@ -0,0 +1,277 @@
+# How SCSS Works in this Config
+
+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.
+
+> 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. Flow Overview
+
+```
+src/styles.scss
+      │
+      │  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/
+  ├── main.js
+  └── styles.css      ← produced directly by esbuild+sassPlugin
+      │
+      │  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/
+  ├── manifest.json   (copied)
+  ├── main.js
+  └── styles.css      ← already in place, no renaming necessary
+```
+
+The two key moments are:
+
+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. SCSS File Path
+
+### 2.1 SCSS File Detection
+
+In `templates/scripts/esbuild.config.ts`, `main()` function:
+
+```ts
+// Check for SCSS first, then CSS in src, then in root
+const srcStylesScssPath = path.join(pluginDir, 'src/styles.scss');
+const srcStylesPath    = path.join(pluginDir, 'src/styles.css');
+const rootStylesPath   = path.join(pluginDir, 'styles.css');
+
+const scssExists = await isValidPath(srcStylesScssPath);
+const stylePath = scssExists
+  ? srcStylesScssPath
+  : (await isValidPath(srcStylesPath))
+    ? srcStylesPath
+    : (await isValidPath(rootStylesPath))
+      ? rootStylesPath
+      : '';
+
+const mainTsPath = path.join(pluginDir, 'src/main.ts');
+const entryPoints = stylePath ? [mainTsPath, stylePath] : [mainTsPath];
+const context = await createBuildContext(buildPath, isProd, entryPoints, scssExists);
+```
+
+- 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
+
+Also in `templates/scripts/esbuild.config.ts`, `createBuildContext()` function:
+
+```ts
+const plugins = [
+  ...(hasSass
+    ? [
+        await (async () => {
+          // @ts-expect-error - esbuild-sass-plugin is installed during injection
+          const { sassPlugin } = await import('esbuild-sass-plugin');
+          return sassPlugin({ syntax: 'scss', style: 'expanded' });
+        })(),
+        {
+          name: 'rename-main-css',
+          setup(build: esbuild.PluginBuild): void {
+            build.onEnd(async (result) => {
+              if (result.errors.length === 0) {
+                await renameMainCss(buildPath);
+              }
+            });
+          }
+        }
+      ]
+    : []),
+```
+
+- 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 Dependency: `esbuild-sass-plugin`
+
+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`
+
+> **Note**: the `.sass` extension (indented syntax) is not supported. Only `.scss` is detected and compiled.
+
+---
+
+## 3. How it is Copied to the Plugins Folder
+
+### 3.1 `renameMainCss` — Safety Net (no-op in current SCSS flow)
+
+In `templates/scripts/utils.ts`, `renameMainCss()` function:
+
+```ts
+export async function renameMainCss(outdir: string): Promise<void> {
+  const mainCssPath = path.join(outdir, 'main.css');
+  const stylesCssPath = path.join(outdir, 'styles.css');
+  try {
+    if (await isValidPath(mainCssPath)) {
+      await rename(mainCssPath, stylesCssPath);
+    }
+  } catch (error: unknown) {
+    console.warn(`Warning: Could not rename main.css to styles.css: ...`);
+  }
+}
+```
+
+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 Copying to the Plugins Folder
+
+In `templates/scripts/utils.ts`, `copyFilesToTargetDir()` function:
+
+```ts
+export async function copyFilesToTargetDir(buildPath: string): Promise<void> {
+  const pluginDir = process.cwd();
+  const manifestSrc  = path.join(pluginDir, 'manifest.json');
+  const manifestDest = path.join(buildPath, 'manifest.json');
+  const cssDest      = path.join(buildPath, 'styles.css');
+  const folderToRemove = path.join(buildPath, '_.._');
+  ...
+  // Copy CSS
+  try {
+    const srcStylesPath  = path.join(pluginDir, 'src/styles.css');
+    const rootStylesPath = path.join(pluginDir, 'styles.css');
+
+    if (await isValidPath(srcStylesPath)) {
+      await copyFile(srcStylesPath, cssDest);
+    }
+    else if (await isValidPath(rootStylesPath)) {
+      await copyFile(rootStylesPath, cssDest);
+      if (await isValidPath(folderToRemove)) {
+        await rm(folderToRemove, { recursive: true });
+      }
+    } else {
+      return;
+    }
+  } ...
+}
+```
+
+> 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 Integration into the esbuild Lifecycle
+
+Also in `templates/scripts/esbuild.config.ts`, the `copy-to-plugins-folder` plugin triggers copying after each build:
+
+```ts
+{
+  name: 'copy-to-plugins-folder',
+  setup: (build: esbuild.PluginBuild): void => {
+    build.onEnd(async () => {
+      if (isProd) {
+        if (process.argv.includes('-r') || process.argv.includes('real')) {
+          await copyFilesToTargetDir(buildPath);
+          console.log(`Successfully installed in ${buildPath}`);
+          await reloadObsidian();
+        } else {
+          const folderToRemove = path.join(buildPath, '_.._');
+          if (await isValidPath(folderToRemove)) {
+            await rm(folderToRemove, { recursive: true });
+          }
+          console.log('Build done in initial folder');
+        }
+      } else {
+        // watch (dev)
+        await copyFilesToTargetDir(buildPath);
+      }
+    });
+  }
+}
+```
+
+- **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 Target: `buildPath`
+
+`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>/
+```
+
+So concretely, the final result for SCSS is:
+
+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"`).
+
+> 💡 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. Where the Injector Installs Everything in the Target Plugin
+
+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 = [
+  'templates/scripts/utils.ts',
+  'templates/scripts/esbuild.config.ts',
+  'templates/scripts/acp.ts',
+  'templates/scripts/update-version.ts',
+  'templates/scripts/release.ts',
+  'templates/scripts/help.ts',
+  'templates/scripts/constants.ts',
+  'templates/scripts/env.ts',
+  'templates/scripts/reload.ts',
+  'templates/scripts/typingsPlugin.ts'
+];
+```
+
+So after injection, the target Obsidian plugin contains `scripts/esbuild.config.ts` (with SCSS logic) and `scripts/utils.ts` (with `renameMainCss` and `copyFilesToTargetDir`).
+
+The injected `.gitignore` (`templates/gitignore.template`) explicitly ignores the intermediate file:
+
+```
+# scss result
+main.css
+```
+
+---
+
+## 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.2",
+  "version": "1.7.5",
   "description": "Global CLI injection tool for Obsidian plugins",
   "type": "module",
   "bin": {
@@ -34,11 +34,17 @@
     "@types/node": "^22.15.26",
     "@typescript-eslint/eslint-plugin": "^8.58.0",
     "@typescript-eslint/parser": "^8.58.0",
+    "builtin-modules": "latest",
     "dedent": "^1.6.0",
+    "dotenv": "latest",
+    "esbuild": "latest",
     "eslint": "latest",
     "eslint-import-resolver-typescript": "latest",
     "jiti": "latest",
+    "obsidian": "*",
+    "obsidian-typings": "latest",
     "prettier": "^3.4.0",
+    "tslib": "2.4.0",
     "tsx": "^4.21.0",
     "typescript": "^5.8.2"
   },

package/scripts/acp.ts

@@ -1,22 +1,23 @@
-import { execSync } 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');
@@ -46,7 +47,7 @@ async function main(): Promise<void> {
     }
 
     // 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();