obsidian-plugin-config 1.1.2 → 1.1.4

package/bin/obsidian-inject.js

@@ -86,6 +86,31 @@ function main() {
       process.exit(1);
     }
 
+    // Clean NPM artifacts if package-lock.json exists
+    const packageLockPath = join(targetPath, 'package-lock.json');
+    if (fs.existsSync(packageLockPath)) {
+      console.log(`🧹 Installation NPM détectée, nettoyage...`);
+
+      try {
+        // Remove package-lock.json
+        fs.unlinkSync(packageLockPath);
+        console.log(`   🗑️  package-lock.json supprimé`);
+
+        // Remove node_modules if it exists
+        const nodeModulesPath = join(targetPath, 'node_modules');
+        if (fs.existsSync(nodeModulesPath)) {
+          fs.rmSync(nodeModulesPath, { recursive: true, force: true });
+          console.log(`   🗑️  node_modules supprimé (sera réinstallé avec Yarn)`);
+        }
+
+        console.log(`   ✅ Artefacts NPM nettoyés pour éviter les conflits Yarn`);
+
+      } catch (cleanError) {
+        console.error(`   ❌ Échec du nettoyage:`, cleanError.message);
+        console.log(`   💡 Supprimez manuellement package-lock.json et node_modules`);
+      }
+    }
+
     // Check if tsx is available locally in target
     let tsxCommand = 'npx tsx';
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-plugin-config",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "description": "Système d'injection pour plugins Obsidian autonomes",
   "type": "module",
   "main": "src/index.ts",

package/scripts/inject-path.ts

@@ -650,6 +650,69 @@ async function ensureTsxAvailable(targetPath: string): Promise<void> {
   }
 }
 
+/**
+ * Clean NPM artifacts to avoid conflicts with Yarn
+ */
+async function cleanNpmArtifacts(targetPath: string): Promise<void> {
+  console.log(`\n🧹 Cleaning NPM artifacts...`);
+
+  const packageLockPath = path.join(targetPath, "package-lock.json");
+  const nodeModulesPath = path.join(targetPath, "node_modules");
+
+  try {
+    // Remove package-lock.json if it exists
+    if (fs.existsSync(packageLockPath)) {
+      fs.unlinkSync(packageLockPath);
+      console.log(`   🗑️  Removed package-lock.json (NPM lock file)`);
+    }
+
+    // Remove node_modules if it exists
+    if (fs.existsSync(nodeModulesPath)) {
+      fs.rmSync(nodeModulesPath, { recursive: true, force: true });
+      console.log(`   🗑️  Removed node_modules (will be reinstalled with Yarn)`);
+    }
+
+    if (!fs.existsSync(packageLockPath) && !fs.existsSync(nodeModulesPath)) {
+      console.log(`   ✅ No NPM artifacts found`);
+    }
+
+  } catch (error) {
+    console.error(`   ❌ Failed to clean NPM artifacts: ${error}`);
+    console.log(`   💡 You may need to manually remove package-lock.json and node_modules`);
+  }
+}
+
+/**
+ * Clean NPM artifacts if package-lock.json is found (evidence of NPM usage)
+ */
+async function cleanNpmArtifactsIfNeeded(targetPath: string): Promise<void> {
+  const packageLockPath = path.join(targetPath, "package-lock.json");
+
+  // Only clean if package-lock.json exists (proof of NPM installation)
+  if (fs.existsSync(packageLockPath)) {
+    console.log(`\n🧹 NPM installation detected, cleaning artifacts...`);
+
+    try {
+      // Remove package-lock.json
+      fs.unlinkSync(packageLockPath);
+      console.log(`   🗑️  Removed package-lock.json`);
+
+      // Remove node_modules if it exists
+      const nodeModulesPath = path.join(targetPath, "node_modules");
+      if (fs.existsSync(nodeModulesPath)) {
+        fs.rmSync(nodeModulesPath, { recursive: true, force: true });
+        console.log(`   🗑️  Removed node_modules (will be reinstalled with Yarn)`);
+      }
+
+      console.log(`   ✅ NPM artifacts cleaned to avoid Yarn conflicts`);
+
+    } catch (error) {
+      console.error(`   ❌ Failed to clean NPM artifacts: ${error}`);
+      console.log(`   💡 You may need to manually remove package-lock.json and node_modules`);
+    }
+  }
+}
+
 /**
  * Check if tsx is installed locally and install it if needed
  */
@@ -711,24 +774,27 @@ export async function performInjection(targetPath: string): Promise<void> {
   console.log(`\n🚀 Starting injection process...`);
 
   try {
-    // Step 1: Ensure tsx is installed
+    // Step 1: Clean NPM artifacts if needed
+    await cleanNpmArtifactsIfNeeded(targetPath);
+
+    // Step 2: Ensure tsx is installed
     await ensureTsxInstalled(targetPath);
 
-    // Step 2: Inject scripts
+    // Step 3: Inject scripts
     await injectScripts(targetPath);
 
-    // Step 3: Update package.json
+    // Step 4: Update package.json
     console.log(`\n📦 Updating package.json...`);
     await updatePackageJson(targetPath);
 
-    // Step 4: Analyze centralized imports (without modifying)
+    // Step 5: Analyze centralized imports (without modifying)
     await analyzeCentralizedImports(targetPath);
 
-    // Step 5: Create required directories
+    // Step 6: Create required directories
     console.log(`\n📁 Creating required directories...`);
     await createRequiredDirectories(targetPath);
 
-    // Step 6: Install dependencies
+    // Step 7: Install dependencies
     await runYarnInstall(targetPath);
 
     // Step 6: Create injection info file

package/templates/scripts/esbuild.config.ts

@@ -93,7 +93,23 @@ async function updateEnvFile(envKey: string, vaultPath: string): Promise<void> {
   console.log(`✅ Updated ${envKey} in .env file`);
 }
 
+function validateVaultPath(vaultPath: string): boolean {
+  // Check if the path contains .obsidian directory
+  const obsidianPath = path.join(vaultPath, ".obsidian");
+  const pluginsPath = path.join(vaultPath, ".obsidian", "plugins");
+
+  return fs.existsSync(obsidianPath) && fs.existsSync(pluginsPath);
+}
+
 function getVaultPath(vaultPath: string): string {
+  // Validate that this is a proper vault path
+  if (!validateVaultPath(vaultPath)) {
+    console.error(`❌ Invalid vault path: ${vaultPath}`);
+    console.error(`   The path must contain a .obsidian/plugins directory`);
+    console.error(`   Please enter a valid Obsidian vault path`);
+    process.exit(1);
+  }
+
   // Check if the path already contains the plugins directory path
   const pluginsPath = path.join(".obsidian", "plugins");
   if (vaultPath.includes(pluginsPath)) {

package/templates/scripts/update-version.ts

@@ -1,8 +1,35 @@
 import { readFile, writeFile } from "fs/promises";
 import dedent from "dedent";
-import { inc, valid } from "semver";
 import { askQuestion, createReadlineInterface, gitExec, ensureGitSync } from "./utils.js";
 
+// Simple version increment functions to avoid semver compatibility issues
+function incrementVersion(version: string, type: 'patch' | 'minor' | 'major'): string {
+  const parts = version.split('.').map(Number);
+  if (parts.length !== 3) return '';
+
+  switch (type) {
+    case 'patch':
+      parts[2]++;
+      break;
+    case 'minor':
+      parts[1]++;
+      parts[2] = 0;
+      break;
+    case 'major':
+      parts[0]++;
+      parts[1] = 0;
+      parts[2] = 0;
+      break;
+  }
+
+  return parts.join('.');
+}
+
+function isValidVersion(version: string): boolean {
+  const versionRegex = /^\d+\.\d+\.\d+$/;
+  return versionRegex.test(version);
+}
+
 const rl = createReadlineInterface();
 
 async function getTargetVersion(currentVersion: string): Promise<string> {
@@ -18,15 +45,16 @@ async function getTargetVersion(currentVersion: string): Promise<string> {
   switch (updateType.trim()) {
     case "p":
     case "1":
-      return inc(currentVersion, "patch") || "";
+      return incrementVersion(currentVersion, "patch");
     case "min":
     case "2":
-      return inc(currentVersion, "minor") || "";
+      return incrementVersion(currentVersion, "minor");
     case "maj":
     case "3":
-      return inc(currentVersion, "major") || "";
+      return incrementVersion(currentVersion, "major");
     default:
-      return valid(updateType.trim()) || "";
+      const trimmed = updateType.trim();
+      return isValidVersion(trimmed) ? trimmed : "";
   }
 }