obsidian-plugin-config 1.5.12 → 1.6.1

package/scripts/build-npm.ts

@@ -201,82 +201,102 @@ main();
 	console.log(`   ✅ Generated ${binPath}`);
 }
 
+/**
+ * Check NPM authentication and prompt login if needed
+ */
+async function ensureNpmAuth(): Promise<void> {
+	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.log(`   ⚠️  Not logged in to NPM\n`);
+		console.log(`🔑 Please login to NPM to publish the package`);
+		console.log(`   Opening browser for authentication...\n`);
+
+		try {
+			execSync('npm login --auth-type=web --registry https://registry.npmjs.org/', {
+				stdio: 'inherit'
+			});
+			console.log(`\n   ✅ Successfully logged in to NPM\n`);
+		} catch {
+			console.error(`\n   ❌ NPM login failed`);
+			console.error(`   Please run 'npm login' manually and try again`);
+			throw new Error('NPM authentication required');
+		}
+	}
+}
+
 /**
  * Complete NPM workflow - Version, Commit, Push, Publish
  */
 async function buildAndPublishNpm(): Promise<void> {
-	console.log(`🚀 Obsidian Plugin Config - Complete NPM Workflow`);
-	console.log(`Full automation: version → exports → bin → commit → publish\n`);
+	console.log(`🚀 Obsidian Plugin Config - NPM Publish Workflow`);
+	console.log(`Automation: version → bin → verify → commit → publish\n`);
 
 	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 0: Check NPM authentication
+		await ensureNpmAuth();
 
 		// Step 1: Update version
-		console.log(`📋 Step 1/7: Updating version...`);
+		console.log(`📋 Step 1/5: Updating version...`);
 		execSync('tsx scripts/update-version-config.ts', { stdio: 'inherit' });
 
-		// Step 2: Update exports
-		console.log(`\n📦 Step 2/7: Updating exports...`);
-		execSync('yarn update-exports', { stdio: 'inherit' });
-
-		// Step 3: Generate bin file
-		console.log(`\n🔧 Step 3/7: Generating bin/obsidian-inject.js...`);
+		// Step 2: Generate bin file
+		console.log(`\n🔧 Step 2/5: Generating bin/obsidian-inject.js...`);
 		await generateBinFile();
 
-		// Step 4: Verify package and sync versions.json
-		console.log(`\n📋 Step 4/7: Verifying package...`);
+		// Step 3: Verify package
+		console.log(`\n📋 Step 3/5: Verifying package...`);
 		verifyPackage();
 
-		// Step 5: Commit and push
-		console.log(`\n📤 Step 5/7: Committing and pushing changes...`);
+		// Step 4: Commit and push
+		console.log(`\n📤 Step 4/5: Committing and pushing changes...`);
 		try {
-			execSync('echo "Publish NPM package" | tsx scripts/acp.ts -b', {
-				stdio: 'inherit'
-			});
-		} catch {
-			console.log(`   ℹ️  No additional changes to commit`);
+			// Add all changes
+			execSync('git add -A', { stdio: 'pipe' });
+			
+			// Check if there are changes to commit
+			const status = execSync('git status --porcelain', { encoding: 'utf8' });
+			if (status.trim()) {
+				const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+				execSync(`git commit -m "Publish NPM package v${packageJson.version}"`, {
+					stdio: 'pipe'
+				});
+				
+				// Get current branch and push
+				const currentBranch = execSync('git rev-parse --abbrev-ref HEAD', {
+					encoding: 'utf8'
+				}).trim();
+				execSync(`git push origin ${currentBranch}`, { stdio: 'inherit' });
+				console.log(`   ✅ Changes committed and pushed`);
+			} else {
+				console.log(`   ℹ️  No changes to commit`);
+			}
+		} catch (error) {
+			console.error(`   ❌ Commit/push failed: ${error instanceof Error ? error.message : String(error)}`);
+			throw error;
 		}
 
-		// Step 6: Publish to NPM
-		console.log(`\n📤 Step 6/7: Publishing to NPM...`);
+		// Step 5: Publish to NPM
+		console.log(`\n📤 Step 5/5: Publishing to NPM...`);
 		execSync('npm publish --registry https://registry.npmjs.org/', {
 			stdio: 'inherit'
 		});
 
-		// Step 7: Update global CLI (auto if --auto-update, else ask)
-		console.log(`\n🌍 Step 7/7: Update global CLI?`);
-		const autoUpdate = process.argv.includes('--auto-update');
-		let doUpdate = autoUpdate;
-		if (!autoUpdate) {
-			const { askConfirmation, createReadlineInterface } =
-				await import('./utils.js');
-			const rl = createReadlineInterface();
-			doUpdate = await askConfirmation(
-				`Install obsidian-plugin-config@latest globally?`,
-				rl
-			);
-			rl.close();
-		}
-		if (doUpdate) {
-			console.log(`   ⏳ Waiting 15s for NPM registry propagation...`);
-			await new Promise((resolve) => setTimeout(resolve, 15000));
-			execSync(
-				'npm install -g obsidian-plugin-config@latest --force --engine-strict=false',
-				{ stdio: 'inherit' }
-			);
-			console.log(`   ✅ Global CLI updated`);
-		}
+		// Optional: Update global CLI automatically
+		console.log(`\n🌍 Updating global CLI...`);
+		console.log(`   ⏳ Waiting 15s for NPM registry propagation...`);
+		await new Promise((resolve) => setTimeout(resolve, 15000));
+		execSync(
+			'npm install -g obsidian-plugin-config@latest --force --engine-strict=false',
+			{ stdio: 'inherit' }
+		);
+		console.log(`   ✅ Global CLI updated`);
 
 		console.log(`\n🎉 Complete workflow successful!`);
 		console.log(`   Test: cd any-plugin && obsidian-inject`);
@@ -296,8 +316,8 @@ function verifyPackage(): void {
 	const requiredScripts = [
 		'scripts/inject-path.ts',
 		'scripts/inject-prompt.ts',
+		'scripts/inject-core.ts',
 		'scripts/utils.ts',
-		'scripts/esbuild.config.ts',
 		'scripts/acp.ts',
 		'scripts/update-version-config.ts',
 		'scripts/help.ts'
@@ -334,26 +354,9 @@ function verifyPackage(): void {
 	}
 	console.log(`   ✅ Bin file ready`);
 
-	// Sync versions.json
-	const versionsPath = 'versions.json';
-	let versions: Record<string, string> = {};
-
-	if (fs.existsSync(versionsPath)) {
-		versions = JSON.parse(fs.readFileSync(versionsPath, 'utf8'));
-	}
-
-	if (!versions[packageJson.version]) {
-		const manifest = JSON.parse(fs.readFileSync('manifest.json', 'utf8'));
-		versions[packageJson.version] = manifest.minAppVersion;
-		fs.writeFileSync(versionsPath, JSON.stringify(versions, null, '  '), 'utf8');
-		console.log(`   ✅ Added version ${packageJson.version} to versions.json`);
-	} else {
-		console.log(`   ✅ Version ${packageJson.version} in versions.json`);
-	}
-
 	// Quick build test
-	execSync('yarn build', { stdio: 'pipe' });
-	console.log(`   ✅ Build test passed`);
+	execSync('tsc --noEmit', { stdio: 'pipe' });
+	console.log(`   ✅ TypeScript check passed`);
 }
 
 // Run the script

package/scripts/help.ts

@@ -2,150 +2,88 @@
 
 console.log(`
 🎯 Obsidian Plugin Config - Quick Help
-Injection system for autonomous Obsidian plugins
+Global CLI injection tool for Obsidian plugins
 
 ═══════════════════════════════════════════════════════════════════
 
-📋 PLUGIN CONFIG COMMANDS
+📋 DEVELOPMENT COMMANDS
 
-INSTALLATION & SETUP:
-  yarn i, install                 # Install dependencies
-  yarn update-exports, ue         # Update package.json exports
-
-GIT & VERSION MANAGEMENT:
+GIT & VERSION:
   yarn acp                        # Add, commit, push
-  yarn bacp                       # Build + add, commit, push
-  yarn v, update-version          # Update version (package.json + versions.json)
+  yarn v, update-version          # Update version
 
-BUILD & TESTING:
-  yarn build                      # TypeScript check (no build needed)
-  yarn dev                        # Start development mode (watch)
-  yarn real                       # Build for production to real vault
+LINTING:
   yarn lint, lint:fix             # ESLint verification/correction
 
-INJECTION (Development phase):
-  yarn inject-prompt <path>       # Interactive injection (recommended)
-  yarn inject-path <path> --yes   # Direct injection with auto-confirm
+INJECTION (local testing):
+  yarn inject-prompt              # Interactive injection
+  yarn inject-path <path>         # Direct injection
   yarn inject <path> --sass       # Injection with SASS support
   yarn check-plugin <path>        # Verification only (dry-run)
 
-NPM PUBLISHING (all-in-one - no acp needed before):
-  yarn npm-publish                # Full workflow (7 steps):
-                                  # 0. NPM auth check
+NPM PUBLISHING:
+  yarn npm-publish                # Full workflow (5 steps):
                                   # 1. version bump
-                                  # 2. update exports
-                                  # 3. generate bin
-                                  # 4. verify package
-                                  # 5. commit + push
-                                  # 6. publish to NPM
-                                  # 7. offer global CLI update
-  yarn build-npm                  # Alias for npm-publish
-
-UPGRADE:
-  yarn upgrade-all                # yarn upgrade + sync template deps
+                                  # 2. generate bin
+                                  # 3. verify package
+                                  # 4. commit + push
+                                  # 5. publish to NPM
 
 HELP:
-  yarn help, h                    # This help
-
-═══════════════════════════════════════════════════════════════════
-
-📦 EXPORTS SYSTEM
-
-The package exposes a single entry point:
-  obsidian-plugin-config          # Main entry — re-exports all modules
-
-Src modules (auto-exported via src/index.ts):
-  modals, tools, utils
-
-After adding a new module to src/, run:
-  yarn update-exports             # Regenerates src/index.ts
+  yarn h                    # This help
 
 ═══════════════════════════════════════════════════════════════════
 
 🏗️  ARCHITECTURE
 
-TWO DISTINCT ROLES:
-  Root (src/, scripts/)           # Local plugin + NPM snippet exports
-  templates/                      # Source of truth for injection
+PURE INJECTION TOOL:
+  templates/                      # Files to inject into target plugins
+  scripts/inject-*.ts             # Injection logic
+  bin/obsidian-inject.js          # Global CLI entry point
 
 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
+  templates/tsconfig.json         # TypeScript config
+  templates/scripts/*             # Scripts copied to target
+  templates/eslint.config.mts     # ESLint config
+  templates/.github/workflows/*   # GitHub Actions
 
 inject-core.ts — shared injection logic:
-  updatePackageJson()             # Reads templates/package.json (not hardcoded)
-  injectScripts()                 # Copies templates/ files to target
-  performInjection()              # Main orchestration function
+  updatePackageJson()             # Merges template package.json
+  injectScripts()                 # Copies template files to target
+  performInjection()              # Main orchestration
 
 inject-path.ts — CLI entry point:
   Parses --yes, --dry-run, --sass flags
 
-inject-prompt.ts — interactive entry point:
-  Prompts for target path interactively
+inject-prompt.ts — interactive entry:
+  Prompts for target path
 
 ═══════════════════════════════════════════════════════════════════
 
-🔧 DEVELOPMENT WORKFLOWS
+🔧 WORKFLOWS
 
-Plugin Config Development:
-  1. yarn i                       # Install dependencies
-  2. yarn update-exports          # Update exports
-  3. yarn dev                     # Test as plugin (optional)
-  4. yarn lint:fix                # Fix code issues
-  5. yarn v                       # Update version + commit + push
-  6. yarn npm-publish             # Publish to NPM
+Development:
+  1. Make changes to templates/ or scripts/
+  2. yarn lint:fix                # Fix code issues
+  3. yarn npm-publish             # Version, commit, publish
 
-Injection Usage:
-  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
+Global CLI Usage:
+  obsidian-inject                 # Inject in current dir
+  obsidian-inject ../my-plugin    # Inject by path
+  obsidian-inject ../my-plugin --sass  # With SASS
+  obsidian-inject --help          # Show help
 
-  Or with local yarn commands:
-    yarn inject-prompt            # Interactive
-    yarn inject-path ../my-plugin # Direct injection
-    yarn check-plugin ../my-plugin # Dry-run only
+Local Testing:
+  yarn inject-prompt              # Interactive
+  yarn inject-path ../my-plugin   # Direct
+  yarn check-plugin ../my-plugin  # Dry-run
 
 SASS Support (--sass flag):
-  What gets added to the target plugin:
-    ✅ esbuild-sass-plugin dependency
-    ✅ Automatic .scss file detection (src/styles.scss priority)
-    ✅ CSS cleanup after compilation
-
-  The standard esbuild.config.ts handles SASS via dynamic import —
-  no separate template needed.
-
-═══════════════════════════════════════════════════════════════════
-
-🚀 COMPLETE WORKFLOWS
-
-STANDARD DEVELOPMENT WORKFLOW:
-  1. yarn i                       # Install dependencies
-  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 file
-                                  # → Verify package
-                                  # → Commit + push to GitHub
-                                  # → Publish to NPM
-
-  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 --force
-  obsidian-inject                 # Test in current plugin dir
-  obsidian-inject ../test-plugin --sass
-
-TESTING AS PLUGIN (Optional):
-  1. Configure .env with TEST_VAULT and REAL_VAULT paths
-  2. yarn dev                     # Watch mode for development
-  3. yarn real                    # Install to real vault
+  ✅ esbuild-sass-plugin dependency
+  ✅ Automatic .scss detection (src/styles.scss priority)
+  ✅ CSS cleanup after compilation
 
 ═══════════════════════════════════════════════════════════════════
 

package/scripts/inject-core.ts

@@ -5,6 +5,7 @@ import path from 'path';
 import { execSync } from 'child_process';
 import { fileURLToPath } from 'url';
 import { isValidPath, gitExec } from './utils.js';
+import type { InjectionOptions } from './inject-options.js';
 
 export interface InjectionPlan {
 	targetPath: string;
@@ -272,7 +273,10 @@ export async function cleanOldLintFiles(targetPath: string): Promise<void> {
 /**
  * Inject scripts and config files
  */
-export async function injectScripts(targetPath: string): Promise<void> {
+export async function injectScripts(
+	targetPath: string,
+	options: InjectionOptions
+): Promise<void> {
 	const scriptsPath = path.join(targetPath, 'scripts');
 
 	if (!(await isValidPath(scriptsPath))) {
@@ -320,22 +324,41 @@ export async function injectScripts(targetPath: string): Promise<void> {
 
 	console.log(`\n📥 Copying scripts from local files...`);
 
-	for (const scriptFile of scriptFiles) {
-		try {
-			const content = copyFromLocal(scriptFile);
-			const fileName = path.basename(scriptFile);
-			const targetFile = path.join(scriptsPath, fileName);
-			fs.writeFileSync(targetFile, content, 'utf8');
-			console.log(`   ✅ ${fileName}`);
-		} catch (error) {
-			console.error(`   ❌ Failed to inject ${scriptFile}: ${error}`);
+	if (options.scripts) {
+		for (const scriptFile of scriptFiles) {
+			try {
+				const content = copyFromLocal(scriptFile);
+				const fileName = path.basename(scriptFile);
+				const targetFile = path.join(scriptsPath, fileName);
+				fs.writeFileSync(targetFile, content, 'utf8');
+				console.log(`   ✅ ${fileName}`);
+			} catch (error) {
+				console.error(`   ❌ Failed to inject ${scriptFile}: ${error}`);
+			}
 		}
+	} else {
+		console.log(`   ⏭️  Skipped (user choice)`);
 	}
 
 	console.log(`\n📥 Copying config files...`);
 
 	// Copy root config files
 	for (const [src, destName] of Object.entries(configFileMap)) {
+		// Check if this file should be injected based on options
+		const shouldInject =
+			(destName === 'tsconfig.json' && options.tsconfig) ||
+			(destName === 'eslint.config.mts' && options.eslint) ||
+			(destName === '.prettierrc' && options.prettier) ||
+			(destName === '.editorconfig' && options.editorconfig) ||
+			(destName === '.gitignore' && options.gitignore) ||
+			(destName === '.env' && options.env) ||
+			(destName === '.npmrc'); // Always inject .npmrc
+
+		if (!shouldInject) {
+			console.log(`   ⏭️  Skipped ${destName} (user choice)`);
+			continue;
+		}
+
 		try {
 			const targetFile = path.join(targetPath, destName);
 			const templateContent = copyFromLocal(src);
@@ -375,39 +398,47 @@ export async function injectScripts(targetPath: string): Promise<void> {
 	}
 
 	// Copy .vscode config files
-	for (const [src, destName] of Object.entries(configVscodeMap)) {
-		try {
-			const content = copyFromLocal(src);
-			const targetFile = path.join(targetPath, destName);
-			const targetDir = path.dirname(targetFile);
-			if (!(await isValidPath(targetDir))) {
-				fs.mkdirSync(targetDir, { recursive: true });
+	if (options.vscode) {
+		for (const [src, destName] of Object.entries(configVscodeMap)) {
+			try {
+				const content = copyFromLocal(src);
+				const targetFile = path.join(targetPath, destName);
+				const targetDir = path.dirname(targetFile);
+				if (!(await isValidPath(targetDir))) {
+					fs.mkdirSync(targetDir, { recursive: true });
+				}
+				fs.writeFileSync(targetFile, content, 'utf8');
+				console.log(`   ✅ ${destName}`);
+			} catch (error) {
+				console.error(`   ❌ Failed to inject ${destName}: ${error}`);
 			}
-			fs.writeFileSync(targetFile, content, 'utf8');
-			console.log(`   ✅ ${destName}`);
-		} catch (error) {
-			console.error(`   ❌ Failed to inject ${destName}: ${error}`);
 		}
+	} else {
+		console.log(`   ⏭️  Skipped .vscode/ (user choice)`);
 	}
 
 	console.log(`\n📥 Copying GitHub workflows from local files...`);
 
-	for (const workflowFile of workflowFiles) {
-		try {
-			const content = copyFromLocal(workflowFile);
-			const relativePath = workflowFile.replace('templates/', '');
-			const targetFile = path.join(targetPath, relativePath);
-			const targetDir = path.dirname(targetFile);
+	if (options.github) {
+		for (const workflowFile of workflowFiles) {
+			try {
+				const content = copyFromLocal(workflowFile);
+				const relativePath = workflowFile.replace('templates/', '');
+				const targetFile = path.join(targetPath, relativePath);
+				const targetDir = path.dirname(targetFile);
 
-			if (!(await isValidPath(targetDir))) {
-				fs.mkdirSync(targetDir, { recursive: true });
-			}
+				if (!(await isValidPath(targetDir))) {
+					fs.mkdirSync(targetDir, { recursive: true });
+				}
 
-			fs.writeFileSync(targetFile, content, 'utf8');
-			console.log(`   ✅ ${relativePath}`);
-		} catch (error) {
-			console.error(`   ❌ Failed to inject ${workflowFile}: ${error}`);
+				fs.writeFileSync(targetFile, content, 'utf8');
+				console.log(`   ✅ ${relativePath}`);
+			} catch (error) {
+				console.error(`   ❌ Failed to inject ${workflowFile}: ${error}`);
+			}
 		}
+	} else {
+		console.log(`   ⏭️  Skipped (user choice)`);
 	}
 }
 
@@ -416,6 +447,7 @@ export async function injectScripts(targetPath: string): Promise<void> {
  */
 export async function updatePackageJson(
 	targetPath: string,
+	options: InjectionOptions,
 	useSass: boolean = false
 ): Promise<void> {
 	const packageJsonPath = path.join(targetPath, 'package.json');
@@ -425,6 +457,11 @@ export async function updatePackageJson(
 		return;
 	}
 
+	if (!options.packageJson) {
+		console.log(`⏭️  Skipped package.json update (user choice)`);
+		return;
+	}
+
 	try {
 		const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
 
@@ -704,6 +741,7 @@ export async function runYarnInstall(targetPath: string): Promise<void> {
  */
 export async function performInjection(
 	targetPath: string,
+	options: InjectionOptions,
 	useSass: boolean = false
 ): Promise<void> {
 	console.log(`\n🚀 Starting injection process...`);
@@ -711,10 +749,10 @@ export async function performInjection(
 	try {
 		await cleanNpmArtifactsIfNeeded(targetPath);
 		await ensureTsxInstalled(targetPath);
-		await injectScripts(targetPath);
+		await injectScripts(targetPath, options);
 
 		console.log(`\n📦 Updating package.json...`);
-		await updatePackageJson(targetPath, useSass);
+		await updatePackageJson(targetPath, options, useSass);
 
 		await analyzeCentralizedImports(targetPath);