@kadi.build/core 0.9.0 → 0.11.0

package/scripts/symlink.mjs

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+
+/**
+ * kadi-core postinstall symlink script
+ *
+ * When kadi-core is installed as an ability (via `kadi install`), it ends up in:
+ *   <project>/abilities/kadi-core@x.y.z/
+ *
+ * This script creates a symlink so that regular Node.js imports work seamlessly:
+ *   <project>/node_modules/@kadi.build/core → <project>/abilities/kadi-core@x.y.z/
+ *
+ * This means users can do:
+ *   import { KadiClient } from '@kadi.build/core';
+ *
+ * without needing to know the ability install path or version number.
+ *
+ * The script is idempotent — safe to run multiple times.
+ */
+
+import { existsSync, mkdirSync, symlinkSync, lstatSync, readlinkSync, unlinkSync } from 'fs';
+import { join, dirname, resolve, relative } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// This script lives at <ability>/scripts/symlink.mjs
+// The ability root is one level up
+const abilityRoot = resolve(__dirname, '..');
+
+/**
+ * Walk up from the ability directory to find the project root.
+ * The project root is the parent of the "abilities" directory.
+ *
+ * Expected structure:
+ *   <project>/abilities/kadi-core@0.10.0/scripts/symlink.mjs
+ *   <project>/node_modules/@kadi.build/core  ← symlink target
+ */
+function findProjectRoot() {
+  let current = abilityRoot;
+
+  // Walk up looking for the abilities/ parent
+  for (let i = 0; i < 5; i++) {
+    const parent = dirname(current);
+    const dirName = current.split('/').pop() || current.split('\\').pop();
+
+    // Check if we're inside an "abilities" directory
+    if (parent && dirname(current).endsWith('abilities')) {
+      // Parent of abilities/ is the project root
+      return dirname(dirname(current));
+    }
+
+    // Also check if the parent directory name starts with "abilities"
+    const parentDirName = dirname(current).split('/').pop() || dirname(current).split('\\').pop();
+    if (parentDirName === 'abilities') {
+      return dirname(dirname(current));
+    }
+
+    current = parent;
+  }
+
+  // Fallback: if abilities/ directory exists as a sibling pattern,
+  // the project root is likely 2 levels up from where the ability is installed
+  // e.g., <project>/abilities/kadi-core@x.y.z → <project>
+  const twoUp = resolve(abilityRoot, '..', '..');
+  if (existsSync(join(twoUp, 'agent.json'))) {
+    return twoUp;
+  }
+
+  return null;
+}
+
+function main() {
+  const projectRoot = findProjectRoot();
+
+  if (!projectRoot) {
+    // Not installed as an ability (maybe running from source) — skip silently
+    console.log('[kadi-core] Not installed as an ability, skipping symlink creation.');
+    return;
+  }
+
+  const symlinkDir = join(projectRoot, 'node_modules', '@kadi.build');
+  const symlinkPath = join(symlinkDir, 'core');
+
+  // Compute relative path from symlink location to ability root
+  const relativeTarget = relative(symlinkDir, abilityRoot);
+
+  // Create the @kadi.build/ directory in node_modules
+  if (!existsSync(symlinkDir)) {
+    mkdirSync(symlinkDir, { recursive: true });
+    console.log(`[kadi-core] Created ${symlinkDir}`);
+  }
+
+  // Check if symlink already exists and points to the right place
+  if (existsSync(symlinkPath)) {
+    try {
+      const stats = lstatSync(symlinkPath);
+      if (stats.isSymbolicLink()) {
+        const currentTarget = readlinkSync(symlinkPath);
+        if (resolve(symlinkDir, currentTarget) === abilityRoot) {
+          console.log(`[kadi-core] Symlink already exists and is correct: ${symlinkPath}`);
+          return;
+        }
+        // Wrong target — remove and recreate
+        console.log(`[kadi-core] Updating symlink (was pointing to ${currentTarget})`);
+        unlinkSync(symlinkPath);
+      } else {
+        // It's a real directory/file — don't touch it
+        console.log(`[kadi-core] ${symlinkPath} exists and is not a symlink — skipping.`);
+        console.log('[kadi-core] If you want the symlink, remove the existing directory first.');
+        return;
+      }
+    } catch {
+      // Can't read — try to remove
+      try { unlinkSync(symlinkPath); } catch { /* ignore */ }
+    }
+  }
+
+  // Create the symlink
+  try {
+    symlinkSync(relativeTarget, symlinkPath, 'dir');
+    console.log(`[kadi-core] Created symlink: ${symlinkPath} → ${relativeTarget}`);
+    console.log('[kadi-core] You can now: import { KadiClient } from \'@kadi.build/core\'');
+  } catch (error) {
+    console.error(`[kadi-core] Failed to create symlink: ${error.message}`);
+    console.error(`[kadi-core] You can create it manually:`);
+    console.error(`  ln -s ${relativeTarget} ${symlinkPath}`);
+  }
+}
+
+main();