obsidian-plugin-config 1.0.2

package/.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+  "npm.packageManager": "yarn",
+  "typescript.preferences.includePackageJsonAutoImports": "off"
+}

package/README.md

@@ -0,0 +1,45 @@
+# Obsidian Plugin Config
+
+Système d'injection pour plugins Obsidian autonomes.
+
+## Installation Globale
+
+```bash
+npm install -g obsidian-plugin-config
+```
+
+## Utilisation
+
+### Injection dans un plugin existant
+
+```bash
+cd votre-plugin-obsidian
+obsidian-inject
+```
+
+### Injection par chemin
+
+```bash
+obsidian-inject /chemin/vers/plugin
+```
+
+## Ce qui est injecté
+
+- **Scripts locaux** : esbuild.config.ts, acp.ts, update-version.ts, utils.ts
+- **Configuration package.json** : scripts, dépendances, protection yarn
+- **Dossiers requis** : .github/workflows
+- **Installation automatique** des dépendances
+
+## Commandes disponibles
+
+```bash
+yarn inject-path <chemin>    # Injection par chemin
+yarn inject <chemin>         # Alias
+yarn migrate <chemin>        # Migration de plugins (développement)
+yarn acp                     # Add-commit-push
+yarn h                       # Aide
+```
+
+## Architecture
+
+Système d'injection qui transforme n'importe quel plugin en version autonome avec scripts locaux intégrés.

package/bin/obsidian-inject.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+
+/**
+ * Obsidian Plugin Config - CLI Entry Point
+ * Global command: obsidian-inject
+ */
+
+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 {
+    // 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
+    });
+    
+    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();

package/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "obsidian-plugin-config",
+  "version": "1.0.2",
+  "description": "Système d'injection pour plugins Obsidian autonomes",
+  "type": "module",
+  "main": "src/index.ts",
+  "bin": {
+    "obsidian-inject": "./bin/obsidian-inject.js"
+  },
+  "license": "MIT",
+  "keywords": [
+    "obsidian",
+    "obsidian-plugin",
+    "typescript",
+    "injection",
+    "autonomous",
+    "cli",
+    "development-tools",
+    "plugin-utilities"
+  ],
+  "scripts": {
+    "start": "yarn install && yarn run update-exports",
+    "update-exports": "node scripts/update-exports.js",
+    "acp": "tsx scripts/acp.ts",
+    "update-version": "tsx scripts/update-version-config.ts",
+    "v": "tsx scripts/update-version-config.ts",
+    "inject-path": "tsx scripts/inject-path.ts",
+    "inject": "tsx scripts/inject-path.ts",
+    "inject-prompt": "tsx scripts/inject-prompt.ts",
+    "build-npm": "tsx scripts/build-npm.ts",
+    "publish-npm": "tsx scripts/build-npm.ts",
+    "help": "tsx scripts/help.ts",
+    "h": "tsx scripts/help.ts",
+    "dev": "tsx scripts/esbuild.config.ts",
+    "build": "tsc -noEmit -skipLibCheck && tsx scripts/esbuild.config.ts production",
+    "real": "tsx scripts/esbuild.config.ts production real",
+    "bacp": "tsx scripts/acp.ts -b",
+    "release": "tsx scripts/release.ts",
+    "r": "tsx scripts/release.ts"
+  },
+  "exports": {
+    ".": "./src/index.ts",
+    "./scripts/*": "./scripts/*",
+    "./modals": "./src/modals/index.ts",
+    "./tools": "./src/tools/index.ts",
+    "./utils": "./src/utils/index.ts"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.26",
+    "@types/semver": "^7.7.0",
+    "builtin-modules": "3.3.0",
+    "dedent": "^1.6.0",
+    "dotenv": "^16.4.5",
+    "esbuild": "latest",
+    "fs-extra": "^11.2.0",
+    "obsidian": "*",
+    "obsidian-typings": "^3.9.5",
+    "semver": "^7.7.2",
+    "tsx": "^4.19.4",
+    "typescript": "^5.8.2"
+  },
+  "dependencies": {
+    "@types/lodash": "^4.17.17",
+    "@types/node": "^22.15.26",
+    "@types/semver": "^7.7.0",
+    "builtin-modules": "3.3.0",
+    "dedent": "^1.6.0",
+    "dotenv": "^16.4.5",
+    "esbuild": "latest",
+    "fs-extra": "^11.2.0",
+    "lodash": "^4.17.21",
+    "obsidian": "*",
+    "obsidian-typings": "^3.9.5",
+    "semver": "^7.7.2",
+    "tsx": "^4.19.4",
+    "typescript": "^5.8.2"
+  },
+  "engines": {
+    "npm": "please-use-yarn",
+    "yarn": ">=1.22.0",
+    "node": ">=16.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/3C0D/obsidian-plugin-config.git"
+  },
+  "author": "3C0D"
+}

package/scripts/acp.ts

@@ -0,0 +1,71 @@
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import {
+  askQuestion,
+  cleanInput,
+  createReadlineInterface,
+  gitExec
+} from "./utils.js";
+
+const rl = createReadlineInterface();
+
+// Check if we're in the centralized config repo
+function isInCentralizedRepo(): boolean {
+  const packageJsonPath = path.join(process.cwd(), "package.json");
+  if (!fs.existsSync(packageJsonPath)) return false;
+
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+  return packageJson.name === "obsidian-plugin-config";
+}
+
+async function main(): Promise<void> {
+  try {
+    if (process.argv.includes("-b")) {
+      console.log("Building...");
+      gitExec("yarn build");
+      console.log("Build successful.");
+    }
+
+    // Only update exports if we're in the centralized repo and not explicitly disabled
+    if (!process.argv.includes("-ne") && !process.argv.includes("--no-exports") && isInCentralizedRepo()) {
+      console.log("Updating exports...");
+      gitExec("yarn run update-exports");
+      console.log("Exports updated.");
+    }
+
+    const input: string = await askQuestion("Enter commit message: ", rl);
+
+    const cleanedInput = cleanInput(input);
+
+    try {
+      gitExec("git add -A");
+      gitExec(`git commit -m "${cleanedInput}"`);
+    } catch {
+      console.log("Commit already exists or failed.");
+      return;
+    }
+
+    // get current branch name
+    const currentBranch = execSync("git rev-parse --abbrev-ref HEAD").toString().trim();
+
+    try {
+      gitExec(`git push origin ${currentBranch}`);
+      console.log("Commit and push successful.");
+    } catch {
+      // new branch
+      console.log(`New branch detected. Setting upstream for ${currentBranch}...`);
+      gitExec(`git push --set-upstream origin ${currentBranch}`);
+      console.log("Upstream branch set and push successful.");
+    }
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : String(error));
+  } finally {
+    rl.close();
+  }
+}
+
+main().catch(console.error).finally(() => {
+  console.log("Exiting...");
+  process.exit();
+});

package/scripts/build-npm.ts

@@ -0,0 +1,137 @@
+#!/usr/bin/env tsx
+
+import fs from "fs";
+import path from "path";
+import { execSync } from "child_process";
+import {
+  askQuestion,
+  askConfirmation,
+  createReadlineInterface
+} from "./utils.js";
+
+const rl = createReadlineInterface();
+
+/**
+ * Build NPM package from local development
+ */
+async function buildNpmPackage(): Promise<void> {
+  console.log(`🏗️  Building NPM package from local development...`);
+
+  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}`);
+    }
+
+    // Step 2: Update bin/obsidian-inject.js if needed
+    console.log(`\n📦 Checking bin/obsidian-inject.js...`);
+    const binPath = "bin/obsidian-inject.js";
+    
+    if (fs.existsSync(binPath)) {
+      console.log(`   ✅ ${binPath} exists`);
+    } else {
+      throw new Error(`Missing bin file: ${binPath}`);
+    }
+
+    // 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(`   ✅ ${field}: ${typeof value === 'object' ? JSON.stringify(value) : value}`);
+    }
+
+    // Step 4: Check if we're logged into NPM
+    console.log(`\n🔐 Checking NPM authentication...`);
+    try {
+      const whoami = execSync('npm whoami', { encoding: 'utf8' }).trim();
+      console.log(`   ✅ Logged in as: ${whoami}`);
+    } catch (error) {
+      console.log(`   ❌ Not logged into NPM`);
+      console.log(`   💡 Run: npm login`);
+      throw new Error("NPM authentication required");
+    }
+
+    // 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 (error) {
+      throw new Error("Build test failed");
+    }
+
+    console.log(`\n✅ Package is ready for NPM publication!`);
+    
+    // Step 6: Ask for confirmation
+    const shouldPublish = await askConfirmation(`\nProceed with NPM publication?`, rl);
+    
+    if (!shouldPublish) {
+      console.log(`❌ Publication cancelled`);
+      return;
+    }
+
+    // Step 7: Publish to NPM
+    console.log(`\n📤 Publishing to NPM...`);
+    execSync('npm publish', { 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`);
+
+  } catch (error) {
+    console.error(`\n❌ Build failed: ${error instanceof Error ? error.message : String(error)}`);
+    throw error;
+  }
+}
+
+/**
+ * Main function
+ */
+async function main(): Promise<void> {
+  try {
+    console.log(`🎯 Obsidian Plugin Config - NPM Package Builder`);
+    console.log(`📦 Prepare and publish NPM package\n`);
+
+    await buildNpmPackage();
+
+  } catch (error) {
+    console.error(`💥 Error: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  } finally {
+    rl.close();
+  }
+}
+
+// Run the script
+main().catch(console.error);