obsidian-plugin-config 1.0.2

package/scripts/inject-prompt.ts

@@ -0,0 +1,399 @@
+#!/usr/bin/env tsx
+
+import fs from "fs";
+import path from "path";
+import { execSync } from "child_process";
+import {
+  askQuestion,
+  askConfirmation,
+  createReadlineInterface,
+  isValidPath
+} from "./utils.js";
+
+const rl = createReadlineInterface();
+
+interface InjectionPlan {
+  targetPath: string;
+  isObsidianPlugin: boolean;
+  hasPackageJson: boolean;
+  hasManifest: boolean;
+  hasScriptsFolder: boolean;
+  currentDependencies: string[];
+}
+
+/**
+ * Analyze the target plugin directory
+ */
+async function analyzePlugin(pluginPath: string): Promise<InjectionPlan> {
+  const packageJsonPath = path.join(pluginPath, "package.json");
+  const manifestPath = path.join(pluginPath, "manifest.json");
+  const scriptsPath = path.join(pluginPath, "scripts");
+
+  const plan: InjectionPlan = {
+    targetPath: pluginPath,
+    isObsidianPlugin: false,
+    hasPackageJson: await isValidPath(packageJsonPath),
+    hasManifest: await isValidPath(manifestPath),
+    hasScriptsFolder: await isValidPath(scriptsPath),
+    currentDependencies: []
+  };
+
+  // Check if it's an Obsidian plugin
+  if (plan.hasManifest) {
+    try {
+      const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+      plan.isObsidianPlugin = !!(manifest.id && manifest.name && manifest.version);
+    } catch (error) {
+      console.warn("Warning: Could not parse manifest.json");
+    }
+  }
+
+  // Get current dependencies
+  if (plan.hasPackageJson) {
+    try {
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+      plan.currentDependencies = [
+        ...Object.keys(packageJson.dependencies || {}),
+        ...Object.keys(packageJson.devDependencies || {})
+      ];
+    } catch (error) {
+      console.warn("Warning: Could not parse package.json");
+    }
+  }
+
+  return plan;
+}
+
+/**
+ * Display injection plan and ask for confirmation
+ */
+async function showInjectionPlan(plan: InjectionPlan): Promise<boolean> {
+  console.log(`\n🎯 Injection Plan for: ${plan.targetPath}`);
+  console.log(`📁 Target: ${path.basename(plan.targetPath)}`);
+  console.log(`📦 Package.json: ${plan.hasPackageJson ? '✅' : '❌'}`);
+  console.log(`📋 Manifest.json: ${plan.hasManifest ? '✅' : '❌'}`);
+  console.log(`📂 Scripts folder: ${plan.hasScriptsFolder ? '✅ (will be updated)' : '❌ (will be created)'}`);
+  console.log(`🔌 Obsidian plugin: ${plan.isObsidianPlugin ? '✅' : '❌'}`);
+
+  if (!plan.isObsidianPlugin) {
+    console.log(`\n⚠️  Warning: This doesn't appear to be a valid Obsidian plugin`);
+    console.log(`   Missing manifest.json or invalid structure`);
+  }
+
+  console.log(`\n📋 Will inject:`);
+  console.log(`   ✅ Local scripts (utils.ts, esbuild.config.ts, acp.ts, etc.)`);
+  console.log(`   ✅ Updated package.json scripts`);
+  console.log(`   ✅ Required dependencies`);
+  console.log(`   🔍 Analyze centralized imports (manual commenting may be needed)`);
+
+  return await askConfirmation(`\nProceed with injection?`, rl);
+}
+
+/**
+ * Find plugin-config root directory
+ */
+function findPluginConfigRoot(): string {
+  // Auto-detect parent, fallback to current
+  const parentPath = path.resolve(process.cwd(), "../obsidian-plugin-config");
+  if (fs.existsSync(parentPath)) {
+    return parentPath;
+  }
+
+  // Fallback to current directory
+  return process.cwd();
+}
+
+/**
+ * Copy file content from local plugin-config directory
+ */
+function copyFromLocal(filePath: string): string {
+  const configRoot = findPluginConfigRoot();
+  const sourcePath = path.join(configRoot, filePath);
+
+  try {
+    return fs.readFileSync(sourcePath, 'utf8');
+  } catch (error) {
+    throw new Error(`Failed to copy ${filePath}: ${error}`);
+  }
+}
+
+/**
+ * Inject scripts from local files
+ */
+async function injectScripts(targetPath: string): Promise<void> {
+  const scriptsPath = path.join(targetPath, "scripts");
+
+  // Create scripts directory if it doesn't exist
+  if (!await isValidPath(scriptsPath)) {
+    fs.mkdirSync(scriptsPath, { recursive: true });
+    console.log(`📁 Created scripts directory`);
+  }
+
+  const scriptFiles = [
+    "scripts/utils.ts",
+    "scripts/esbuild.config.ts",
+    "scripts/acp.ts",
+    "scripts/update-version.ts",
+    "scripts/release.ts",
+    "scripts/help.ts"
+  ];
+
+  const configFiles = [
+    "templates/tsconfig.json"
+  ];
+
+  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}`);
+    }
+  }
+
+  console.log(`\n📥 Copying config files from local files...`);
+
+  for (const configFile of configFiles) {
+    try {
+      const content = copyFromLocal(configFile);
+      const fileName = path.basename(configFile);
+      const targetFile = path.join(targetPath, fileName);
+
+      // Force inject tsconfig.json to ensure correct template
+      if (fileName === 'tsconfig.json' && await isValidPath(targetFile)) {
+        console.log(`   🔄 ${fileName} exists, updating with template`);
+      }
+
+      fs.writeFileSync(targetFile, content, 'utf8');
+      console.log(`   ✅ ${fileName}`);
+    } catch (error) {
+      console.error(`   ❌ Failed to inject ${configFile}: ${error}`);
+    }
+  }
+}
+
+/**
+ * Update package.json with autonomous configuration
+ */
+async function updatePackageJson(targetPath: string): Promise<void> {
+  const packageJsonPath = path.join(targetPath, "package.json");
+
+  if (!await isValidPath(packageJsonPath)) {
+    console.log(`❌ No package.json found, skipping package.json update`);
+    return;
+  }
+
+  try {
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+
+    // Update scripts
+    packageJson.scripts = {
+      ...packageJson.scripts,
+      "start": "yarn install && yarn dev",
+      "dev": "tsx scripts/esbuild.config.ts",
+      "build": "tsc -noEmit -skipLibCheck && tsx scripts/esbuild.config.ts production",
+      "real": "tsx scripts/esbuild.config.ts production real",
+      "acp": "tsx scripts/acp.ts",
+      "bacp": "tsx scripts/acp.ts -b",
+      "update-version": "tsx scripts/update-version.ts",
+      "v": "tsx scripts/update-version.ts",
+      "release": "tsx scripts/release.ts",
+      "r": "tsx scripts/release.ts",
+      "help": "tsx scripts/help.ts",
+      "h": "tsx scripts/help.ts"
+    };
+
+    // Remove centralized dependency
+    if (packageJson.dependencies && packageJson.dependencies["obsidian-plugin-config"]) {
+      delete packageJson.dependencies["obsidian-plugin-config"];
+      console.log(`   🗑️  Removed obsidian-plugin-config dependency`);
+    }
+
+    // Add required dependencies
+    if (!packageJson.devDependencies) packageJson.devDependencies = {};
+
+    const requiredDeps = {
+      "@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",
+      "obsidian": "*",
+      "obsidian-typings": "^3.9.5",
+      "semver": "^7.7.2",
+      "tsx": "^4.19.4",
+      "typescript": "^5.8.2"
+    };
+
+    let addedDeps = 0;
+    let updatedDeps = 0;
+    for (const [dep, version] of Object.entries(requiredDeps)) {
+      if (!packageJson.devDependencies[dep]) {
+        packageJson.devDependencies[dep] = version;
+        addedDeps++;
+      } else if (packageJson.devDependencies[dep] !== version) {
+        packageJson.devDependencies[dep] = version;
+        updatedDeps++;
+      }
+    }
+
+    // Ensure yarn protection
+    if (!packageJson.engines) packageJson.engines = {};
+    packageJson.engines.npm = "please-use-yarn";
+    packageJson.engines.yarn = ">=1.22.0";
+
+    // Write updated package.json
+    fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2), 'utf8');
+    console.log(`   ✅ Updated package.json (${addedDeps} new, ${updatedDeps} updated dependencies)`);
+
+  } catch (error) {
+    console.error(`   ❌ Failed to update package.json: ${error}`);
+  }
+}
+
+/**
+ * Run yarn install in target directory
+ */
+async function runYarnInstall(targetPath: string): Promise<void> {
+  console.log(`\n📦 Installing dependencies...`);
+
+  try {
+    execSync('yarn install', {
+      cwd: targetPath,
+      stdio: 'inherit'
+    });
+    console.log(`   ✅ Dependencies installed successfully`);
+  } catch (error) {
+    console.error(`   ❌ Failed to install dependencies: ${error}`);
+    console.log(`   💡 You may need to run 'yarn install' manually in the target directory`);
+  }
+}
+
+/**
+ * Direct injection function (without argument parsing)
+ */
+async function performInjectionDirect(targetPath: string): Promise<void> {
+  console.log(`\n🚀 Starting injection process...`);
+
+  try {
+    // Step 1: Inject scripts
+    await injectScripts(targetPath);
+
+    // Step 2: Update package.json
+    console.log(`\n📦 Updating package.json...`);
+    await updatePackageJson(targetPath);
+
+    // Step 3: Install dependencies
+    await runYarnInstall(targetPath);
+
+    console.log(`\n✅ Injection completed successfully!`);
+    console.log(`\n📋 Next steps:`);
+    console.log(`   1. cd ${targetPath}`);
+    console.log(`   2. yarn build    # Test the build`);
+    console.log(`   3. yarn start    # Test development mode`);
+    console.log(`   4. yarn acp      # Commit changes (or yarn bacp for build+commit)`);
+
+  } catch (error) {
+    console.error(`\n❌ Injection failed: ${error}`);
+    throw error;
+  }
+}
+
+/**
+ * Ask user for target directory path
+ */
+async function promptForTargetPath(): Promise<string> {
+  console.log(`\n📁 Select target plugin directory:`);
+  console.log(`   Common paths (copy-paste ready):`);
+  console.log(`   - ../test-sample-plugin`);
+  console.log(`   - ../sample-plugin-modif`);
+  console.log(`   - ../my-obsidian-plugin`);
+  console.log(`   💡 Tip: You can paste paths with or without quotes`);
+
+  while (true) {
+    const rawInput = await askQuestion(`\nEnter plugin directory path: `, rl);
+
+    if (!rawInput.trim()) {
+      console.log(`❌ Please enter a valid path`);
+      continue;
+    }
+
+    // Remove quotes if present and trim
+    const cleanPath = rawInput.trim().replace(/^["']|["']$/g, '');
+    const resolvedPath = path.resolve(cleanPath);
+
+    if (!await isValidPath(resolvedPath)) {
+      console.log(`❌ Directory not found: ${resolvedPath}`);
+      const retry = await askConfirmation(`Try again?`, rl);
+      if (!retry) {
+        throw new Error("User cancelled");
+      }
+      continue;
+    }
+
+    console.log(`📁 Target directory: ${resolvedPath}`);
+    return resolvedPath;
+  }
+}
+
+/**
+ * Main function
+ */
+async function main(): Promise<void> {
+  try {
+    console.log(`🎯 Obsidian Plugin Config - Interactive Injection Tool`);
+    console.log(`📥 Inject autonomous configuration with prompts\n`);
+
+    // Check if path provided as argument
+    const args = process.argv.slice(2);
+    let targetPath: string;
+
+    if (args.length > 0) {
+      // Use provided argument
+      const rawPath = args[0];
+      const cleanPath = rawPath.trim().replace(/^["']|["']$/g, '');
+      targetPath = path.resolve(cleanPath);
+
+      if (!await isValidPath(targetPath)) {
+        console.error(`❌ Directory not found: ${targetPath}`);
+        process.exit(1);
+      }
+
+      console.log(`📁 Using provided path: ${targetPath}`);
+    } else {
+      // Prompt for target directory
+      targetPath = await promptForTargetPath();
+    }
+
+    // Analyze the plugin
+    console.log(`\n🔍 Analyzing plugin...`);
+    const plan = await analyzePlugin(targetPath);
+
+    // Show plan and ask for confirmation
+    const confirmed = await showInjectionPlan(plan);
+
+    if (!confirmed) {
+      console.log(`❌ Injection cancelled by user`);
+      process.exit(0);
+    }
+
+    // Perform injection directly
+    await performInjectionDirect(targetPath);
+
+  } 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);

package/scripts/open-editor.mjs

@@ -0,0 +1,18 @@
+import { execSync } from 'child_process';
+import { platform } from 'os';
+
+const isWindows = platform() === 'win32';
+
+console.log(`Starting the ${process.env.npm_lifecycle_event} process...\n`);
+console.log('- Dependencies installed');
+
+try {
+    if (isWindows) {
+        execSync("start /B code .", { stdio: "ignore", shell: true });
+    } else {
+        execSync("code .", { stdio: "ignore" });
+    }
+    console.log('- Opened current folder in VSCode');
+} catch (error) {
+    console.warn('Warning: Could not open VSCode');
+}

package/scripts/release.ts

@@ -0,0 +1,97 @@
+import {
+  writeFile,
+  stat
+} from "fs/promises";
+import { execSync } from "child_process";
+import dedent from "dedent";
+import {
+  askQuestion,
+  askConfirmation,
+  createReadlineInterface
+} 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\"");
+    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}`);
+  }
+  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-exports.js

@@ -0,0 +1,91 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+// Get current directory (equivalent to __dirname in CommonJS)
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Scans the src directory for subdirectories with index.ts files
+ * and generates the main index.ts with appropriate exports
+ */
+function updateExports() {
+  console.log('🔄 Updating exports...');
+
+  const srcDir = path.join(__dirname, '../src');
+  const mainIndexPath = path.join(srcDir, 'index.ts');
+
+  try {
+    // Check if src directory exists
+    if (!fs.existsSync(srcDir)) {
+      console.error('❌ src directory not found');
+      return;
+    }
+
+    // Get all subdirectories in src/
+    const items = fs.readdirSync(srcDir, { withFileTypes: true });
+    const subdirs = items
+      .filter(item => item.isDirectory())
+      .map(item => item.name);
+
+    // Find subdirectories that have an index.ts file
+    const exportsToGenerate = [];
+
+    for (const subdir of subdirs) {
+      const subdirPath = path.join(srcDir, subdir);
+      const indexPath = path.join(subdirPath, 'index.ts');
+
+      if (fs.existsSync(indexPath)) {
+        exportsToGenerate.push(subdir);
+        console.log(`✅ Found exportable module: ${subdir}`);
+      }
+    }
+
+    // Generate the export statements
+    const exportStatements = exportsToGenerate
+      .map(subdir => `export * from './${subdir}/index.js';`)
+      .join('\n');
+
+    // Add header comment
+    const fileContent = `// Auto-generated exports - DO NOT EDIT MANUALLY
+// Run 'npm run update-exports' to regenerate this file
+
+${exportStatements}
+`;
+
+    // Write the main index.ts file
+    fs.writeFileSync(mainIndexPath, fileContent, 'utf8');
+
+    // Update package.json exports
+    const packageJsonPath = path.join(__dirname, '../package.json');
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+
+    // Generate exports object
+    const exportsObj = {
+      ".": "./src/index.ts",
+      "./scripts/*": "./scripts/*"
+    };
+
+    // Add exports for each module
+    for (const subdir of exportsToGenerate) {
+      exportsObj[`./${subdir}`] = `./src/${subdir}/index.ts`;
+    }
+
+    packageJson.exports = exportsObj;
+
+    // Write updated package.json
+    fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2), 'utf8');
+
+    console.log(`✅ Updated ${mainIndexPath}`);
+    console.log(`✅ Updated ${packageJsonPath} exports`);
+    console.log(`📦 Generated ${exportsToGenerate.length} export(s): ${exportsToGenerate.join(', ')}`);
+
+  } catch (error) {
+    console.error('❌ Error updating exports:', error.message);
+    process.exit(1);
+  }
+}
+
+// Run the function
+updateExports();

package/scripts/update-version-config.ts

@@ -0,0 +1,98 @@
+import { readFile, writeFile } from "fs/promises";
+import dedent from "dedent";
+import { inc, valid } from "semver";
+import { createReadlineInterface, askQuestion, gitExec } from "./utils";
+
+
+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 updateConfigVersions(targetVersion: string): Promise<void> {
+    try {
+        await Promise.all([
+            updateJsonFile("package.json", json => json.version = targetVersion),
+            updateJsonFile("versions.json", json => json[targetVersion] = "1.8.9")
+        ]);
+    } catch (error) {
+        console.error("Error updating config 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 updateConfigVersions(targetVersion);
+            console.log(`Files updated to version ${targetVersion}`);
+
+            // Add files to git
+            gitExec("git add 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 {
+            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();
+});