obsidian-plugin-config 1.1.1 → 1.1.3

package/bin/obsidian-inject.js

@@ -78,16 +78,74 @@ function main() {
   console.log(`📦 Depuis: ${packageRoot}\n`);
 
   try {
+    // Check if target directory has package.json
+    const targetPackageJson = join(targetPath, 'package.json');
+    if (!fs.existsSync(targetPackageJson)) {
+      console.error(`❌ Erreur: package.json non trouvé dans ${targetPath}`);
+      console.error(`   Assurez-vous que c'est un projet Node.js valide.`);
+      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 {
+      execSync('npx tsx --version', {
+        cwd: targetPath,
+        stdio: 'pipe'
+      });
+      console.log(`✅ tsx disponible localement`);
+    } catch {
+      console.log(`⚠️  tsx non trouvé, installation en cours...`);
+
+      // Install tsx locally in target directory
+      try {
+        execSync('yarn add -D tsx', {
+          cwd: targetPath,
+          stdio: 'inherit'
+        });
+        console.log(`✅ tsx installé avec succès`);
+      } catch (installError) {
+        console.error(`❌ Échec de l'installation de tsx:`, installError.message);
+        console.error(`   Essayez d'installer tsx manuellement: cd "${targetPath}" && yarn add -D tsx`);
+        process.exit(1);
+      }
+    }
+
     // Execute the injection script with tsx
     const command = `npx tsx "${injectScriptPath}" "${targetPath}"`;
 
     execSync(command, {
       stdio: 'inherit',
-      cwd: userCwd  // Use user's current directory, not package directory
+      cwd: targetPath  // Use target directory to ensure tsx is available
     });
-    
+
     console.log(`\n✅ Injection terminée avec succès !`);
-    
+
   } catch (error) {
     console.error(`\n❌ Erreur lors de l'injection:`, error.message);
     process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-plugin-config",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "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