obsidian-plugin-config 1.3.9 → 1.3.12

package/bin/obsidian-inject.js

@@ -3,7 +3,7 @@
 /**
  * Obsidian Plugin Config - CLI Entry Point
  * Global command: obsidian-inject
- * Version: 1.3.9
+ * Version: 1.3.12
  */
 
 import { execSync } from 'child_process';

package/docs/LLM-GUIDE.md

@@ -0,0 +1,111 @@
+# LLM Guide — obsidian-plugin-config
+
+## The two distinct roles of this repo
+
+### 1. Local plugin (root)
+
+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`.
+
+### 2. Injection system (templates/)
+
+`templates/` is the **source of truth** for everything injected into target plugins.
+
+- `templates/scripts/` — scripts that will be 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`
+
+The injection logic lives in `scripts/inject-core.ts`, `scripts/inject-path.ts`, `scripts/inject-prompt.ts`.
+
+---
+
+## Critical distinction
+
+| | 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 |
+
+**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.**
+
+---
+
+## What injection does
+
+`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
+
+`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/`
+
+---
+
+## Scripts: local vs injected
+
+Local scripts (`scripts/`) and template scripts (`templates/scripts/`) are **the same scripts**, with one difference:
+
+- `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 updating a shared script (e.g. `acp.ts`), update **both** `scripts/acp.ts` and `templates/scripts/acp.ts`.
+
+---
+
+## 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`
+
+---
+
+## obsidian-typings paths (current)
+
+The correct paths for `obsidian-typings` in `tsconfig.json` (confirmed against installed `node_modules`):
+
+```json
+"types": ["obsidian-typings"],
+"paths": {
+  "obsidian-typings/implementations": [
+    "./node_modules/obsidian-typings/dist/cjs/implementations.d.cts",
+    "./node_modules/obsidian-typings/dist/esm/implementations.mjs"
+  ]
+}
+```
+
+These 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-plugin-config",
-  "version": "1.3.9",
+  "version": "1.3.12",
   "description": "Système d'injection pour plugins Obsidian autonomes",
   "type": "module",
   "main": "src/index.ts",
@@ -59,7 +59,7 @@
     "fs-extra": "^11.2.0",
     "jiti": "latest",
     "obsidian": "*",
-    "obsidian-typings": "^3.9.5",
+    "obsidian-typings": "latest",
     "prettier": "^3.4.0",
     "semver": "^7.7.2",
     "tsx": "^4.19.4",
@@ -76,7 +76,7 @@
     "fs-extra": "^11.2.0",
     "lodash": "^4.17.21",
     "obsidian": "*",
-    "obsidian-typings": "^3.9.5",
+    "obsidian-typings": "latest",
     "semver": "^7.7.2",
     "tsx": "^4.19.4",
     "typescript": "^5.8.2"

package/scripts/build-npm.ts

@@ -204,6 +204,18 @@ function buildAndPublishNpm(): void {
   );
 
   try {
+    // Step 0: Check NPM login
+    console.log(`🔐 Checking NPM authentication...`);
+    try {
+      const whoami = execSync('npm whoami --registry https://registry.npmjs.org/', {
+        stdio: 'pipe', encoding: 'utf8'
+      }).trim();
+      console.log(`   ✅ Logged in as: ${whoami}\n`);
+    } catch {
+      console.error(`   ❌ Not logged in to NPM. Run: npm login`);
+      process.exit(1);
+    }
+
     // Step 1: Update version in package.json only
     // (no commit yet - we'll do one big commit after)
     console.log(`📋 Step 1/6: Updating version...`);
@@ -212,21 +224,21 @@ function buildAndPublishNpm(): void {
     });
 
     // Step 2: Update exports automatically
-    console.log(`\n📦 Step 2/6: Updating exports...`);
+    console.log(`\n📦 Step 2/7: Updating exports...`);
     execSync('yarn update-exports', { stdio: 'inherit' });
 
     // Step 3: Generate bin file (uses updated version)
-    console.log(`\n🔧 Step 3/6: Generating bin/obsidian-inject.js...`);
+    console.log(`\n🔧 Step 3/7: Generating bin/obsidian-inject.js...`);
     generateBinFile();
 
     // Step 4: Verify package and sync versions.json
     // (must happen before commit so versions.json is included)
-    console.log(`\n📋 Step 4/6: Verifying package...`);
+    console.log(`\n📋 Step 4/7: Verifying package...`);
     verifyPackage();
 
     // Step 5: Commit and push ALL changes together
     // (package.json version, bin/, versions.json, exports)
-    console.log(`\n📤 Step 5/6: Committing and pushing changes...`);
+    console.log(`\n📤 Step 5/7: Committing and pushing changes...`);
     try {
       execSync(
         'echo "Publish NPM package" | tsx scripts/acp.ts -b',
@@ -237,7 +249,7 @@ function buildAndPublishNpm(): void {
     }
 
     // Step 6: Publish to NPM
-    console.log(`\n📤 Step 6/6: Publishing to NPM...`);
+    console.log(`\n📤 Step 6/7: Publishing to NPM...`);
     execSync(
       'npm publish --registry https://registry.npmjs.org/',
       { stdio: 'inherit' }

package/scripts/help.ts

@@ -29,8 +29,10 @@ INJECTION (Development phase):
   yarn inject <path> --sass       # Injection with SASS support
   yarn check-plugin <path>        # Verification only (dry-run)
 
-NPM PUBLISHING:
-  yarn npm-publish                # Complete NPM workflow (exports + bin + publish)
+NPM PUBLISHING (all-in-one - no acp needed before):
+  yarn npm-publish                # Full workflow:
+                                  # version → exports → bin
+                                  # → commit+push → publish
   yarn build-npm                  # Alias for npm-publish
 
 HELP:
@@ -53,21 +55,27 @@ After adding a new module to src/, run:
 
 🏗️  ARCHITECTURE
 
+TWO DISTINCT ROLES:
+  Root (src/, scripts/)           # Local plugin + NPM snippet exports
+  templates/                      # Source of truth for injection
+
+templates/ → what gets injected:
+  templates/package.json          # Base deps/scripts for target plugins
+  templates/package-sass.json     # Extra deps when --sass is used
+  templates/tsconfig.json         # TypeScript config for target plugins
+  templates/scripts/*             # Scripts copied to <target>/scripts/
+  templates/eslint.config.mts     # ESLint config for target plugins
+
 inject-core.ts — shared injection logic:
-  analyzePlugin()                 # Analyze target plugin directory
+  updatePackageJson()             # Reads templates/package.json (not hardcoded)
+  injectScripts()                 # Copies templates/ files to target
   performInjection()              # Main orchestration function
-  updatePackageJson()             # Inject scripts + dependencies
-  injectScripts()                 # Copy templates to target
-  ensurePluginConfigClean()       # Auto-commit before injection
 
 inject-path.ts — CLI entry point:
   Parses --yes, --dry-run, --sass flags
-  Calls performInjection() from inject-core
 
 inject-prompt.ts — interactive entry point:
   Prompts for target path interactively
-  Supports --sass flag
-  Calls performInjection() from inject-core
 
 ═══════════════════════════════════════════════════════════════════
 
@@ -82,17 +90,15 @@ Plugin Config Development:
   6. yarn npm-publish             # Publish to NPM
 
 Injection Usage:
-  Recommended structure:
-    my-plugins/
-    ├── obsidian-plugin-config/   # This repo
-    ├── my-plugin-1/
-    └── my-plugin-2/
-
-  Usage:
-    yarn inject-prompt ../my-plugin   # Interactive (recommended)
-    yarn inject-path ../my-plugin     # Direct injection
-    yarn inject ../my-plugin --sass   # With SASS support
-    yarn check-plugin ../my-plugin    # Verification only
+  Usage (from plugin directory or by path):
+    obsidian-inject               # Inject in current dir
+    obsidian-inject ../my-plugin  # Inject by path
+    obsidian-inject ../my-plugin --sass  # With SASS
+
+  Or with local yarn commands:
+    yarn inject-prompt            # Interactive
+    yarn inject-path ../my-plugin # Direct injection
+    yarn check-plugin ../my-plugin # Dry-run only
 
 SASS Support (--sass flag):
   What gets added to the target plugin:
@@ -109,23 +115,22 @@ SASS Support (--sass flag):
 
 STANDARD DEVELOPMENT WORKFLOW:
   1. yarn i                       # Install dependencies
-  2. Make changes to obsidian-plugin-config
-  3. yarn update-exports          # Update exports if needed
-  4. yarn lint:fix                # Fix any linting issues
-  5. yarn v                       # Update version + commit + push GitHub
-  6. yarn npm-publish             # Complete NPM workflow
-
-AUTOMATED WORKFLOW (One command):
-  yarn npm-publish                # Does EVERYTHING automatically:
-                                  # → Update version
+  2. Make changes to src/ or templates/
+  3. yarn lint:fix                # Fix any linting issues
+  4. yarn npm-publish             # Does EVERYTHING:
+                                  # → Ask for version bump type
                                   # → Update exports
-                                  # → Generate bin/obsidian-inject.js
+                                  # → Generate bin file
                                   # → Verify package
+                                  # → Commit + push to GitHub
                                   # → Publish to NPM
 
-AFTER NPM PUBLISH - Testing:
+  Note: yarn acp is only needed for intermediate commits
+  (not required before npm-publish).
+
+AFTER NPM PUBLISH - Update global CLI:
   npm install -g obsidian-plugin-config@latest
-  obsidian-inject ../test-plugin
+  obsidian-inject                 # Test in current plugin dir
   obsidian-inject ../test-plugin --sass
 
 TESTING AS PLUGIN (Optional):

package/scripts/inject-core.ts

@@ -229,6 +229,15 @@ export async function cleanOldScripts(scriptsPath: string): Promise<void> {
     }
   }
 
+  const obsoleteRootFiles = ["help-plugin.ts"];
+  for (const fileName of obsoleteRootFiles) {
+    const filePath = path.join(path.dirname(scriptsPath), fileName);
+    if (await isValidPath(filePath)) {
+      fs.unlinkSync(filePath);
+      console.log(`🗑️  Removed obsolete root file: ${fileName}`);
+    }
+  }
+
   const obsoleteFiles = ["start.mjs", "start.js"];
   for (const fileName of obsoleteFiles) {
     const filePath = path.join(scriptsPath, fileName);
@@ -449,6 +458,18 @@ export async function updatePackageJson(
   try {
     const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
 
+    const configRoot = findPluginConfigRoot();
+    const templatePkg = JSON.parse(
+      fs.readFileSync(path.join(configRoot, "templates/package.json"), "utf8")
+    );
+
+    if (useSass) {
+      const sassPkg = JSON.parse(
+        fs.readFileSync(path.join(configRoot, "templates/package-sass.json"), "utf8")
+      );
+      Object.assign(templatePkg.devDependencies, sassPkg.devDependencies);
+    }
+
     const obsoleteScripts = ["version"];
     for (const script of obsoleteScripts) {
       if (packageJson.scripts?.[script]) {
@@ -459,20 +480,7 @@ export async function updatePackageJson(
 
     packageJson.scripts = {
       ...packageJson.scripts,
-      start: "yarn install && yarn dev",
-      dev: "tsx scripts/esbuild.config.ts",
-      build: "tsc -noEmit -skipLibCheck && tsx scripts/esbuild.config.ts production",
-      real: "tsx scripts/esbuild.config.ts production real",
-      acp: "tsx scripts/acp.ts",
-      bacp: "tsx scripts/acp.ts -b",
-      "update-version": "tsx scripts/update-version.ts",
-      v: "tsx scripts/update-version.ts",
-      release: "tsx scripts/release.ts",
-      r: "tsx scripts/release.ts",
-      help: "tsx scripts/help.ts",
-      h: "tsx scripts/help.ts",
-      lint: "eslint . --ext .ts",
-      "lint:fix": "eslint . --ext .ts --fix"
+      ...templatePkg.scripts
     };
 
     if (packageJson.dependencies?.["obsidian-plugin-config"]) {
@@ -482,44 +490,24 @@ export async function updatePackageJson(
 
     if (!packageJson.devDependencies) packageJson.devDependencies = {};
 
-    const requiredDeps: Record<string, string> = {
-      "@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",
-      jiti: "latest",
-      obsidian: "*",
-      "obsidian-typings": "^3.9.5",
-      prettier: "^3.4.0",
-      semver: "^7.7.2",
-      tsx: "^4.19.4",
-      typescript: "^5.8.2",
-      ...(useSass ? { "esbuild-sass-plugin": "^3.3.1" } : {})
-    };
+    const requiredDeps: Record<string, string> = templatePkg.devDependencies;
 
     let addedDeps = 0;
     let updatedDeps = 0;
     for (const [dep, version] of Object.entries(requiredDeps)) {
       if (!packageJson.devDependencies[dep]) {
-        packageJson.devDependencies[dep] = version;
+        packageJson.devDependencies[dep] = version as string;
         addedDeps++;
       } else if (packageJson.devDependencies[dep] !== version) {
-        packageJson.devDependencies[dep] = version;
+        packageJson.devDependencies[dep] = version as string;
         updatedDeps++;
       }
     }
 
     if (!packageJson.engines) packageJson.engines = {};
-    packageJson.engines.npm = "please-use-yarn";
-    packageJson.engines.yarn = ">=1.22.0";
-    packageJson.type = "module";
+    packageJson.engines.npm = templatePkg.engines.npm;
+    packageJson.engines.yarn = templatePkg.engines.yarn;
+    packageJson.type = templatePkg.type;
 
     fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2), "utf8");
     console.log(`   ✅ Updated package.json (${addedDeps} new, ${updatedDeps} updated dependencies)`);

package/src/main.ts

@@ -1,121 +1,118 @@
-import {
-  App,
-  Plugin,
-  PluginSettingTab,
-  Setting,
-  Notice
-} from "obsidian";
-import { showConfirmModal } from "./modals/GenericConfirmModal.ts";
+import { App, Plugin, PluginSettingTab, Setting, Notice } from 'obsidian';
+import { showConfirmModal } from './modals/GenericConfirmModal.ts';
 // import { showTestMessage, getRandomEmoji } from "obsidian-plugin-config/tools";
 
 interface MyPluginSettings {
-  mySetting: string;
+	mySetting: string;
 }
 
 const DEFAULT_SETTINGS: MyPluginSettings = {
-  mySetting: "default"
+	mySetting: 'default'
 };
 
 export default class ObsidianPluginConfigPlugin extends Plugin {
-  settings: MyPluginSettings;
-
-  async onload(): Promise<void> {
-    console.log("Loading obsidian-plugin-config plugin for testing NPM exports");
-    await this.loadSettings();
-
-    this.addCommand({
-      id: 'show-confirmation-modal',
-      name: 'Test Confirmation Modal (Local)',
-      callback: () => this.showConfirmationModal()
-    });
-
-    this.addCommand({
-      id: 'show-centralized-modal',
-      name: 'Test Confirmation Modal (Centralized)',
-      callback: () => this.showCentralizedModal()
-    });
-
-    this.addCommand({
-      id: 'test-tools',
-      name: 'Test Centralized Tools',
-      callback: () => {
-        // const message = showTestMessage();
-        // const emoji = getRandomEmoji();
-        new Notice(`🎯 Test centralized tools (commented for autonomous mode)`);
-      }
-    });
-
-    this.addSettingTab(new PluginConfigSettingTab(this.app, this));
-  }
-
-  private showConfirmationModal(): void {
-    showConfirmModal(this.app, {
-      title: "Confirmation requise",
-      message: "Êtes-vous sûr de vouloir effectuer cette action ? Cette action ne peut pas être annulée.",
-      confirmText: "Confirmer",
-      cancelText: "Annuler",
-      onConfirm: () => {
-        new Notice("Action confirmée !");
-        console.log("Action confirmée par l'utilisateur");
-      },
-      onCancel: () => {
-        new Notice("Action annulée.");
-        console.log("Action annulée par l'utilisateur");
-      }
-    });
-  }
-
-  private showCentralizedModal(): void {
-    showConfirmModal(this.app, {
-      title: "Centralized Modal Test",
-      message: "This modal comes from the centralized configuration! Pretty cool, right?",
-      confirmText: "Awesome!",
-      cancelText: "Not bad",
-      onConfirm: () => {
-        new Notice("Centralized modal confirmed! 🎉");
-      },
-      onCancel: () => {
-        new Notice("Centralized modal cancelled 😢");
-      }
-    });
-  }
-
-  async loadSettings(): Promise<void> {
-    this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());
-  }
-
-  async saveSettings(): Promise<void> {
-    await this.saveData(this.settings);
-  }
+	settings: MyPluginSettings;
+
+	async onload(): Promise<void> {
+		console.log('Loading obsidian-plugin-config plugin for testing NPM exports');
+		await this.loadSettings();
+
+		this.addCommand({
+			id: 'show-confirmation-modal',
+			name: 'Test Confirmation Modal (Local)',
+			callback: () => this.showConfirmationModal()
+		});
+
+		this.addCommand({
+			id: 'show-centralized-modal',
+			name: 'Test Confirmation Modal (Centralized)',
+			callback: () => this.showCentralizedModal()
+		});
+
+		this.addCommand({
+			id: 'test-tools',
+			name: 'Test Centralized Tools',
+			callback: () => {
+				// const message = showTestMessage();
+				// const emoji = getRandomEmoji();
+				new Notice(`🎯 Test centralized tools (commented for autonomous mode)`);
+			}
+		});
+
+		this.addSettingTab(new PluginConfigSettingTab(this.app, this));
+	}
+
+	private showConfirmationModal(): void {
+		showConfirmModal(this.app, {
+			title: 'Confirmation requise',
+			message:
+				'Êtes-vous sûr de vouloir effectuer cette action ? Cette action ne peut pas être annulée.',
+			confirmText: 'Confirmer',
+			cancelText: 'Annuler',
+			onConfirm: () => {
+				new Notice('Action confirmée !');
+				console.log("Action confirmée par l'utilisateur");
+			},
+			onCancel: () => {
+				new Notice('Action annulée.');
+				console.log("Action annulée par l'utilisateur");
+			}
+		});
+	}
+
+	private showCentralizedModal(): void {
+		showConfirmModal(this.app, {
+			title: 'Centralized Modal Test',
+			message:
+				'This modal comes from the centralized configuration! Pretty cool, right?',
+			confirmText: 'Awesome!',
+			cancelText: 'Not bad',
+			onConfirm: () => {
+				new Notice('Centralized modal confirmed! 🎉');
+			},
+			onCancel: () => {
+				new Notice('Centralized modal cancelled 😢');
+			}
+		});
+	}
+
+	async loadSettings(): Promise<void> {
+		this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());
+	}
+
+	async saveSettings(): Promise<void> {
+		await this.saveData(this.settings);
+	}
 }
 
 class PluginConfigSettingTab extends PluginSettingTab {
-  plugin: ObsidianPluginConfigPlugin;
-
-  constructor(app: App, plugin: ObsidianPluginConfigPlugin) {
-    super(app, plugin);
-    this.plugin = plugin;
-  }
-
-  display(): void {
-    const { containerEl } = this;
-    containerEl.empty();
-
-    containerEl.createEl('h2', { text: 'Obsidian Plugin Config Settings' });
-    containerEl.createEl('p', {
-      text: 'This plugin is used for testing NPM exports and development of the obsidian-plugin-config system.'
-    });
-
-    new Setting(containerEl)
-      .setName('Test Setting')
-      .setDesc('A test setting for development purposes')
-      .addText(text => text
-        .setPlaceholder('Enter test value')
-        .setValue(this.plugin.settings.mySetting)
-        .onChange(async (value) => {
-          this.plugin.settings.mySetting = value;
-          await this.plugin.saveSettings();
-        }));
-  }
+	plugin: ObsidianPluginConfigPlugin;
+
+	constructor(app: App, plugin: ObsidianPluginConfigPlugin) {
+		super(app, plugin);
+		this.plugin = plugin;
+	}
+
+	display(): void {
+		const { containerEl } = this;
+		containerEl.empty();
+
+		containerEl.createEl('h2', { text: 'Obsidian Plugin Config Settings' });
+		containerEl.createEl('p', {
+			text: 'This plugin is used for testing NPM exports and development of the obsidian-plugin-config system.'
+		});
+
+		new Setting(containerEl)
+			.setName('Test Setting')
+			.setDesc('A test setting for development purposes')
+			.addText((text) =>
+				text
+					.setPlaceholder('Enter test value')
+					.setValue(this.plugin.settings.mySetting)
+					.onChange(async (value) => {
+						this.plugin.settings.mySetting = value;
+						await this.plugin.saveSettings();
+					})
+			);
+	}
 }
-