obsidian-plugin-config 1.1.7 → 1.1.8

package/bin/obsidian-inject.js

@@ -3,6 +3,7 @@
 /**
  * Obsidian Plugin Config - CLI Entry Point
  * Global command: obsidian-inject
+ * Version: 1.1.8
  */
 
 import { execSync } from 'child_process';
@@ -50,7 +51,7 @@ Pour plus d'informations: https://github.com/3C0D/obsidian-plugin-config
 
 function main() {
   const args = process.argv.slice(2);
-  
+
   // Handle help flags
   if (args.includes('--help') || args.includes('-h')) {
     showHelp();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-plugin-config",
-  "version": "1.1.7",
+  "version": "1.1.8",
   "description": "Système d'injection pour plugins Obsidian autonomes",
   "type": "module",
   "main": "src/index.ts",
@@ -34,6 +34,7 @@
     "lint:fix": "eslint . --ext .ts --fix",
     "inject-path": "tsx scripts/inject-path.ts",
     "inject-prompt": "tsx scripts/inject-prompt.ts",
+    "inject": "tsx scripts/inject-prompt.ts",
     "check-plugin": "tsx scripts/inject-path.ts --dry-run",
     "build-npm": "tsx scripts/build-npm.ts",
     "publish-npm": "tsx scripts/build-npm.ts",

package/scripts/build-npm.ts

@@ -1,135 +1,284 @@
 #!/usr/bin/env tsx
 
 import fs from "fs";
+import path from "path";
 import { execSync } from "child_process";
-import {
-  askConfirmation,
-  createReadlineInterface
-} from "./utils.js";
 
-const rl = createReadlineInterface();
+/**
+ * Generate bin/obsidian-inject.js from template
+ */
+async function generateBinFile(): Promise<void> {
+  console.log(`\n🔧 Generating bin/obsidian-inject.js...`);
+
+  const binDir = "bin";
+  const binPath = path.join(binDir, "obsidian-inject.js");
+
+  // Ensure bin directory exists
+  if (!fs.existsSync(binDir)) {
+    fs.mkdirSync(binDir, { recursive: true });
+    console.log(`   📁 Created ${binDir} directory`);
+  }
+
+  // Read package.json for version info
+  const packageJson = JSON.parse(fs.readFileSync("package.json", "utf8"));
+
+  const binContent = `#!/usr/bin/env node
 
 /**
- * Build NPM package from local development
+ * Obsidian Plugin Config - CLI Entry Point
+ * Global command: obsidian-inject
+ * Version: ${packageJson.version}
  */
-async function buildNpmPackage(): Promise<void> {
-  console.log(`🏗️  Building NPM package from local development...`);
+
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join, isAbsolute, resolve } from 'path';
+import fs from 'fs';
+
+// Get the directory of this script
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageRoot = dirname(__dirname);
+
+// Path to the injection script
+const injectScriptPath = join(packageRoot, 'scripts', 'inject-path.ts');
+
+function showHelp() {
+  console.log(\`
+Obsidian Plugin Config - Global CLI
+Système d'injection pour plugins Obsidian autonomes
+
+UTILISATION:
+  obsidian-inject                    # Injection dans le répertoire courant
+  obsidian-inject <chemin>           # Injection par chemin
+  obsidian-inject --help, -h         # Afficher cette aide
+
+EXEMPLES:
+  cd mon-plugin && obsidian-inject
+  obsidian-inject ../mon-autre-plugin
+  obsidian-inject "C:\\\\Users\\\\dev\\\\plugins\\\\mon-plugin"
+
+CE QUI EST INJECTÉ:
+  ✅ Scripts locaux (esbuild.config.ts, acp.ts, utils.ts, etc.)
+  ✅ Configuration package.json (scripts, dépendances)
+  ✅ Protection yarn obligatoire
+  ✅ Installation automatique des dépendances
+
+ARCHITECTURE:
+  - Plugin devient AUTONOME avec scripts locaux
+  - Aucune dépendance externe requise après injection
+  - Mise à jour possible via re-injection
+
+Pour plus d'informations: https://github.com/3C0D/obsidian-plugin-config
+\`);
+}
+
+function main() {
+  const args = process.argv.slice(2);
+
+  // Handle help flags
+  if (args.includes('--help') || args.includes('-h')) {
+    showHelp();
+    process.exit(0);
+  }
+
+  // Check if injection script exists
+  if (!fs.existsSync(injectScriptPath)) {
+    console.error(\`❌ Erreur: Script d'injection non trouvé à \${injectScriptPath}\`);
+    console.error(\`   Vérifiez que obsidian-plugin-config est correctement installé.\`);
+    process.exit(1);
+  }
+
+  // Determine target path (resolve relative to user's current directory)
+  const userCwd = process.cwd();
+  let targetPath = args[0] || userCwd;
+
+  // If relative path, resolve from user's current directory
+  if (args[0] && !isAbsolute(args[0])) {
+    targetPath = resolve(userCwd, args[0]);
+  }
+
+  console.log(\`🎯 Obsidian Plugin Config - Injection Globale\`);
+  console.log(\`📁 Cible: \${targetPath}\`);
+  console.log(\`📦 Depuis: \${packageRoot}\\n\`);
 
   try {
-    // Step 1: Verify all scripts are ready
-    console.log(`\n📋 Verifying scripts...`);
-
-    const requiredScripts = [
-      "scripts/inject-path.ts",
-      "scripts/inject-prompt.ts",
-      "scripts/utils.ts",
-      "scripts/esbuild.config.ts",
-      "scripts/acp.ts",
-      "scripts/update-version.ts",
-      "scripts/release.ts",
-      "scripts/help.ts"
-    ];
-
-    for (const script of requiredScripts) {
-      if (!fs.existsSync(script)) {
-        throw new Error(`Missing required script: ${script}`);
-      }
-      console.log(`   ✅ ${script}`);
+    // 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);
     }
 
-    // Step 2: Update bin/obsidian-inject.js if needed
-    console.log(`\n📦 Checking bin/obsidian-inject.js...`);
-    const binPath = "bin/obsidian-inject.js";
+    // 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...\`);
 
-    if (fs.existsSync(binPath)) {
-      console.log(`   ✅ ${binPath} exists`);
-    } else {
-      throw new Error(`Missing bin file: ${binPath}`);
-    }
+      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)\`);
+        }
 
-    // Step 3: Verify package.json is ready for NPM
-    console.log(`\n📄 Verifying package.json for NPM...`);
-    const packageJson = JSON.parse(fs.readFileSync("package.json", "utf8"));
-
-    const requiredFields = {
-      name: packageJson.name,
-      version: packageJson.version,
-      description: packageJson.description,
-      bin: packageJson.bin,
-      repository: packageJson.repository,
-      author: packageJson.author
-    };
-
-    for (const [field, value] of Object.entries(requiredFields)) {
-      if (!value) {
-        throw new Error(`Missing required package.json field: ${field}`);
+        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\`);
       }
-      console.log(`   ✅ ${field}: ${typeof value === 'object' ? JSON.stringify(value) : value}`);
     }
 
-    // Step 4: Check if we're logged into NPM
-    console.log(`\n🔐 Checking NPM authentication...`);
+    // Check if tsx is available locally in target
+    let tsxCommand = 'npx tsx';
     try {
-      const whoami = execSync('npm whoami', { encoding: 'utf8' }).trim();
-      console.log(`   ✅ Logged in as: ${whoami}`);
+      execSync('npx tsx --version', {
+        cwd: targetPath,
+        stdio: 'pipe'
+      });
+      console.log(\`✅ tsx disponible localement\`);
     } catch {
-      console.log(`   ❌ Not logged into NPM`);
-      console.log(`   💡 Run: npm login`);
-      throw new Error("NPM authentication required");
-    }
+      console.log(\`⚠️  tsx non trouvé, installation en cours...\`);
 
-    // Step 5: Run tests to ensure everything works
-    console.log(`\n🧪 Running quick test...`);
-    try {
-      execSync('yarn build', { stdio: 'inherit' });
-      console.log(`   ✅ Build test passed`);
-    } catch {
-      throw new Error("Build test failed");
+      // 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);
+      }
     }
 
-    console.log(`\n✅ Package is ready for NPM publication!`);
+    // Execute the injection script with tsx
+    const command = \`npx tsx "\${injectScriptPath}" "\${targetPath}"\`;
 
-    // Step 6: Ask for confirmation
-    const shouldPublish = await askConfirmation(`\nProceed with NPM publication?`, rl);
+    execSync(command, {
+      stdio: 'inherit',
+      cwd: targetPath  // Use target directory to ensure tsx is available
+    });
 
-    if (!shouldPublish) {
-      console.log(`❌ Publication cancelled`);
-      return;
-    }
+    console.log(\`\\n✅ Injection terminée avec succès !\`);
+
+  } catch (error) {
+    console.error(\`\\n❌ Erreur lors de l'injection:\`, error.message);
+    process.exit(1);
+  }
+}
+
+// Run the CLI
+main();
+`;
+
+  fs.writeFileSync(binPath, binContent, "utf8");
+  console.log(`   ✅ Generated ${binPath}`);
+}
+
+/**
+ * Build and publish NPM package - Complete workflow
+ */
+function buildAndPublishNpm(): void {
+  console.log(`🚀 Obsidian Plugin Config - NPM Build & Publish`);
+  console.log(`Complete workflow: exports → bin → verify → publish\n`);
+
+  try {
+    // Step 1: Update exports automatically
+    console.log(`📦 Step 1/4: Updating exports...`);
+    execSync('yarn update-exports', { stdio: 'inherit' });
+
+    // Step 2: Generate bin file
+    console.log(`\n🔧 Step 2/4: Generating bin/obsidian-inject.js...`);
+    generateBinFile();
+
+    // Step 3: Verify package is ready
+    console.log(`\n📋 Step 3/4: Verifying package...`);
+    verifyPackage();
 
-    // Step 7: Publish to NPM
-    console.log(`\n📤 Publishing to NPM...`);
-    execSync('npm publish', { stdio: 'inherit' });
+    // Step 4: Publish to NPM
+    console.log(`\n📤 Step 4/4: Publishing to NPM...`);
+    execSync('npm publish --registry https://registry.npmjs.org/', { stdio: 'inherit' });
 
     console.log(`\n🎉 Package published successfully!`);
     console.log(`\n📋 Next steps:`);
-    console.log(`   1. npm install -g ${packageJson.name}`);
-    console.log(`   2. cd any-obsidian-plugin && obsidian-inject`);
-    console.log(`   3. Test the global installation`);
+    console.log(`   1. npm install -g obsidian-plugin-config`);
+    console.log(`   2. Test injection: cd any-plugin && obsidian-inject`);
 
   } catch (error) {
     console.error(`\n❌ Build failed: ${error instanceof Error ? error.message : String(error)}`);
-    throw error;
+    process.exit(1);
   }
 }
 
 /**
- * Main function
+ * Verify package is ready for publication
  */
-async function main(): Promise<void> {
-  try {
-    console.log(`🎯 Obsidian Plugin Config - NPM Package Builder`);
-    console.log(`📦 Prepare and publish NPM package\n`);
+function verifyPackage(): void {
+  // Check required scripts
+  const requiredScripts = [
+    "scripts/inject-path.ts",
+    "scripts/inject-prompt.ts",
+    "scripts/utils.ts",
+    "scripts/esbuild.config.ts",
+    "scripts/acp.ts",
+    "scripts/update-version-config.ts",
+    "scripts/help.ts"
+  ];
+
+  for (const script of requiredScripts) {
+    if (!fs.existsSync(script)) {
+      throw new Error(`Missing required script: ${script}`);
+    }
+  }
+  console.log(`   ✅ All required scripts present`);
 
-    await buildNpmPackage();
+  // Check package.json
+  const packageJson = JSON.parse(fs.readFileSync("package.json", "utf8"));
+  const requiredFields = ['name', 'version', 'description', 'bin', 'repository', 'author'];
 
-  } catch (error) {
-    console.error(`💥 Error: ${error instanceof Error ? error.message : String(error)}`);
-    process.exit(1);
-  } finally {
-    rl.close();
+  for (const field of requiredFields) {
+    if (!packageJson[field]) {
+      throw new Error(`Missing required package.json field: ${field}`);
+    }
   }
+  console.log(`   ✅ Package.json valid (v${packageJson.version})`);
+
+  // Check bin file exists
+  if (!fs.existsSync("bin/obsidian-inject.js")) {
+    throw new Error(`Missing bin file: bin/obsidian-inject.js`);
+  }
+  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]) {
+    versions[packageJson.version] = "1.8.9";
+    fs.writeFileSync(versionsPath, JSON.stringify(versions, null, "\t"), "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`);
 }
 
 // Run the script
-main().catch(console.error);
+buildAndPublishNpm();

package/scripts/help.ts

@@ -9,24 +9,27 @@ Injection system for autonomous Obsidian plugins
 📋 PLUGIN CONFIG COMMANDS
 
 DEVELOPMENT:
-  yarn start                      # Install dependencies + update exports
-  yarn build                      # Build the project
-  yarn dev                        # Development build
-  yarn real                       # Build to real vault
+  yarn start, i                   # Install dependencies + update exports
+  yarn update-exports, ue         # Update package.json exports
+  yarn build                      # TypeScript check (no build needed)
+  yarn lint, lint:fix             # ESLint verification/correction
 
 INJECTION:
-  yarn inject-path <path> --yes   # Automatic injection
-  yarn inject-prompt <path>       # Interactive injection with prompts
+  yarn inject-prompt <path>       # Interactive injection (recommended)
+  yarn inject-path <path> --yes   # Direct injection with auto-confirm
   yarn check-plugin <path>        # Verification without injection
 
 GIT & VERSION:
-  yarn acp                        # Add, commit, push
+  yarn acp                        # Add, commit, push (with Git sync)
   yarn bacp                       # Build + add, commit, push
-  yarn v, update-version          # Update version
+  yarn v, update-version          # Update version (package.json + versions.json)
 
 NPM PUBLISHING:
-  yarn build-npm                  # Build NPM package
-  yarn publish-npm                # Publish to NPM
+  yarn build-npm                  # Build + publish NPM package
+  yarn publish-npm                # Alias for build-npm
+
+HELP:
+  yarn run help, h                # This help
 
 ═══════════════════════════════════════════════════════════════════
 
@@ -45,5 +48,17 @@ Usage:
 
 ═══════════════════════════════════════════════════════════════════
 
+🚀 COMPLETE WORKFLOW (Development → NPM)
+
+  1. Make changes to obsidian-plugin-config
+  2. yarn lint:fix                 # Fix any linting issues
+  3. yarn v                        # Update version (package.json + versions.json)
+  4. yarn bacp                     # Commit and push to GitHub
+  5. yarn build-npm                # Build and publish to NPM
+  6. npm install -g obsidian-plugin-config  # Update global package
+  7. Test injection on target plugins
+
+═══════════════════════════════════════════════════════════════════
+
 `);
 

package/versions.json

@@ -11,5 +11,6 @@
 	"1.0.9": "1.8.9",
 	"1.0.10": "1.8.9",
 	"1.1.6": "1.8.9",
-	"1.1.7": "1.8.9"
+	"1.1.7": "1.8.9",
+	"1.1.8": "1.8.9"
 }

package/scripts/release.ts

@@ -1,104 +0,0 @@
-import {
-  writeFile,
-  stat
-} from "fs/promises";
-import { execSync } from "child_process";
-import dedent from "dedent";
-import {
-  askConfirmation,
-  createReadlineInterface,
-  ensureGitSync
-} from "./utils.js";
-
-const rl = createReadlineInterface();
-
-const body = ".github/workflows/release-body.md";
-
-async function checkOrCreateFile(filename: string): Promise<void> {
-  try {
-    await stat(filename);
-  } catch {
-    console.log(`Creating ${filename} because it doesn't exist. Avoid deleting it.`);
-    await writeFile(filename, "");
-  }
-}
-
-async function createReleaseNotesFile(tagMessage: string, tag: string): Promise<void> {
-  await writeFile(body, tagMessage);
-  console.log(`Release notes for tag ${tag} have been written to release-body.md`);
-}
-
-async function handleExistingTag(tag: string): Promise<boolean> {
-  const confirmed = await askConfirmation(`Tag ${tag} already exists. Do you want to replace it?`, rl);
-
-  if (!confirmed) {
-    console.log("Operation aborted");
-    return false;
-  }
-
-  execSync(`git tag -d ${tag}`);
-  execSync(`git push origin :refs/tags/${tag}`);
-  console.log(`Deleted existing tag ${tag} locally and remotely.`);
-  return true;
-}
-
-async function createTag(): Promise<void> {
-  const currentVersion = process.env.npm_package_version;
-  const tag = `${currentVersion}`;
-
-  await checkOrCreateFile(body);
-  const exists = execSync("git ls-remote --tags origin").toString().includes(`refs/tags/${tag}`);
-
-  if (exists && !(await handleExistingTag(tag))) {
-    rl.close();
-    return;
-  }
-  await doCommit(currentVersion, tag);
-}
-
-
-
-async function doCommit(currentVersion: string | undefined, tag: string): Promise<void> {
-  rl.question(`Enter the commit message for version ${currentVersion}: `, async (message) => {
-    doNextSteps(message, tag);
-    rl.close();
-  });
-}
-
-async function doNextSteps(message: string, tag: string): Promise<void> {
-  const messages = message.split("\\n");
-  const toShow = message.replace(/\\n/g, "\n");
-  await createReleaseNotesFile(toShow, tag);
-  const tagMessage = messages.map(m => `-m "${m}"`).join(" ");
-
-  try {
-    execSync("git add -A");
-    execSync("git commit -m \"update tag description\"");
-
-    // Ensure Git is synchronized before pushing
-    await ensureGitSync();
-
-    execSync("git push");
-  } catch (error: any) {
-    console.error("Error:", error.message);
-  }
-  try {
-    execSync(`git tag -a ${tag} ${tagMessage}`);
-  } catch {
-    execSync(`git tag -d ${tag}`);
-    execSync(`git push origin :refs/tags/${tag}`);
-    console.log("Fixed");
-    execSync(`git tag -a ${tag} ${tagMessage}`);
-  }
-  // Ensure Git is synchronized before pushing tag
-  await ensureGitSync();
-
-  execSync(`git push origin ${tag}`);
-  console.log(`Release ${tag} pushed to repo.`);
-  console.log(dedent`
-        with message:
-            ${toShow}
-    `);
-}
-
-createTag().catch(console.error);

package/scripts/update-version.ts

@@ -1,105 +0,0 @@
-import { readFile, writeFile } from "fs/promises";
-import dedent from "dedent";
-import { inc, valid } from "semver";
-import { askQuestion, createReadlineInterface, gitExec, ensureGitSync } from "./utils.js";
-
-const rl = createReadlineInterface();
-
-async function getTargetVersion(currentVersion: string): Promise<string> {
-  const updateType = await askQuestion(dedent`
-        Current version: ${currentVersion}
-        Kind of update:
-            patch(1.0.1) -> type 1 or p
-            minor(1.1.0) -> type 2 or min
-            major(2.0.0) -> type 3 or maj
-            or version number (e.g. 2.0.0)
-        Enter choice: `, rl);
-
-  switch (updateType.trim()) {
-    case "p":
-    case "1":
-      return inc(currentVersion, "patch") || "";
-    case "min":
-    case "2":
-      return inc(currentVersion, "minor") || "";
-    case "maj":
-    case "3":
-      return inc(currentVersion, "major") || "";
-    default:
-      return valid(updateType.trim()) || "";
-  }
-}
-
-async function updateJsonFile(filename: string, updateFn: (json: any) => void): Promise<void> {
-  try {
-    const content = JSON.parse(await readFile(filename, "utf8"));
-    updateFn(content);
-    await writeFile(filename, JSON.stringify(content, null, "\t"));
-  } catch (error) {
-    console.error(`Error updating ${filename}:`, error instanceof Error ? error.message : String(error));
-    throw error;
-  }
-}
-
-async function updateManifestVersions(targetVersion: string): Promise<void> {
-  try {
-    const manifest = JSON.parse(await readFile("manifest.json", "utf8"));
-    const { minAppVersion } = manifest;
-
-    await Promise.all([
-      updateJsonFile("manifest.json", json => json.version = targetVersion),
-      updateJsonFile("versions.json", json => json[targetVersion] = minAppVersion),
-      updateJsonFile("package.json", json => json.version = targetVersion),
-      // updateJsonFile("package-lock.json", json => json.version = targetVersion)
-    ]);
-  } catch (error) {
-    console.error("Error updating manifest versions:", error instanceof Error ? error.message : String(error));
-    throw error;
-  }
-}
-
-async function updateVersion(): Promise<void> {
-  try {
-    const currentVersion = process.env.npm_package_version || "1.0.0";
-    const targetVersion = await getTargetVersion(currentVersion);
-
-    if (!targetVersion) {
-      console.log("Invalid version");
-      return;
-    }
-
-    try {
-      // Update all files first
-      await updateManifestVersions(targetVersion);
-      console.log(`Files updated to version ${targetVersion}`);
-
-      // Add files to git
-      gitExec("git add manifest.json package.json versions.json");
-      gitExec(`git commit -m "Updated to version ${targetVersion}"`);
-      console.log("Changes committed");
-    } catch (error) {
-      console.error("Error during update or commit:", error instanceof Error ? error.message : String(error));
-      console.log("Operation failed.");
-      return;
-    }
-
-    try {
-      // Ensure Git is synchronized before pushing
-      await ensureGitSync();
-
-      gitExec("git push");
-      console.log(`Version successfully updated to ${targetVersion} and pushed.`);
-    } catch (pushError) {
-      console.error("Failed to push version update:", pushError instanceof Error ? pushError.message : String(pushError));
-    }
-  } catch (error) {
-    console.error("Error:", error instanceof Error ? error.message : String(error));
-  } finally {
-    rl.close();
-  }
-}
-
-updateVersion().catch(console.error).finally(() => {
-  console.log("Exiting...");
-  process.exit();
-});