@robylon/react-native-sdk 2.0.18 → 2.0.19-staging.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robylon/react-native-sdk",
-  "version": "2.0.18",
+  "version": "2.0.19-staging.0",
   "description": "React Native SDK for Robylon",
   "main": "lib/commonjs/index.js",
   "module": "lib/module/index.js",
@@ -22,8 +22,12 @@
     "version:staging": "npm version prerelease --preid staging",
     "version:production": "npm version patch",
     "publish:dev": "npm run clean && npm run prebuild:dev && npm run version:dev && npm run build:dev && npm publish --tag dev",
-    "publish:staging": "npm run clean && npm run prebuild:staging && npm run version:staging && npm run build:staging && npm publish --tag staging",
-    "publish:production": "npm run clean && npm run prebuild:production && npm run version:production && npm run build:production && npm publish --tag latest"
+    "publish:staging": "node scripts/validate-publish.js staging && npm version $(node scripts/get-next-version.js staging) && npm publish --tag staging",
+    "publish:production": "node scripts/validate-publish.js production && npm version $(node scripts/get-next-version.js production) && npm publish",
+    "publish:hotfix": "node scripts/validate-publish.js hotfix && npm version $(node scripts/get-next-version.js hotfix) && npm publish --tag hotfix",
+    "postinstall": "node scripts/setup-git-hooks.js",
+    "branch": "node scripts/create-branch.js",
+    "tag": "node scripts/create-version-tag.js"
   },
   "peerDependencies": {
     "react": "*",
@@ -37,10 +41,12 @@
     "babel-plugin-inline-dotenv": "^1.7.0",
     "babel-plugin-transform-inline-environment-variables": "^0.4.4",
     "env-cmd": "^10.1.0",
+    "husky": "^8.0.3",
     "react": "^18.0.0",
-    "react-native": "^0.70.0",
+    "react-native": "^0.76.5",
     "react-native-builder-bob": "^0.20.0",
     "rimraf": "^6.0.1",
+    "semver": "^7.5.4",
     "typescript": "^4.5.2"
   },
   "react-native-builder-bob": {
@@ -70,5 +76,10 @@
   },
   "author": "",
   "license": "ISC",
-  "dependencies": {}
+  "husky": {
+    "hooks": {
+      "commit-msg": "sh scripts/validate-branch-name.sh",
+      "post-checkout": "node scripts/prevent-direct-branch.js"
+    }
+  }
 }

package/scripts/create-branch.js

@@ -0,0 +1,560 @@
+const { execSync } = require("child_process");
+const readline = require("readline");
+const semver = require("semver");
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+// Calculate the next patch version
+const getNextPatchVersion = (currentVersion) => {
+  const versionParts = currentVersion.split(".");
+  const nextPatch = parseInt(versionParts[2]) + 1;
+  return `${versionParts[0]}.${versionParts[1]}.${nextPatch}`;
+};
+
+// Validate branch name format
+const isValidFeatureName = (name) => /^[a-z0-9-]+$/.test(name);
+
+// Get the latest version from remote main
+const getLatestMainVersion = () => {
+  try {
+    // Fetch latest from remote
+    execSync("git fetch origin main --quiet");
+
+    // Get package.json content from remote main
+    const remotePackageJson = execSync(
+      "git show origin/main:package.json"
+    ).toString();
+
+    return JSON.parse(remotePackageJson).version;
+  } catch (error) {
+    throw new Error(
+      "Failed to get version from remote main. Ensure you have internet connection and repository access."
+    );
+  }
+};
+
+// Get target version for new branches
+const getTargetVersion = () => {
+  try {
+    // Get current branch
+    const currentBranch = execSync("git rev-parse --abbrev-ref HEAD")
+      .toString()
+      .trim();
+
+    // If we're on a release branch, use its version for new features
+    if (currentBranch.startsWith("release/v")) {
+      return currentBranch.split("/v")[1];
+    }
+
+    // Otherwise, use next version from main
+    const mainVersion = getLatestMainVersion();
+    return getNextPatchVersion(mainVersion);
+  } catch (error) {
+    throw new Error("Failed to determine target version");
+  }
+};
+
+// Validate that we're not creating conflicting branches
+const validateVersionAvailability = async (targetVersion) => {
+  try {
+    // Get all remote branches
+    const remoteBranches = execSync("git ls-remote --heads origin")
+      .toString()
+      .split("\n")
+      .filter(Boolean)
+      .map((line) => line.split("/").slice(3).join("/"));
+
+    // Check for existing feature branches with same version
+    const conflictingBranches = remoteBranches.filter((branch) =>
+      branch.startsWith(`feature/v${targetVersion}/`)
+    );
+
+    if (conflictingBranches.length > 0) {
+      console.log(
+        "\n⚠️  Warning: The following branches already exist for version",
+        targetVersion
+      );
+      conflictingBranches.forEach((branch) => console.log(`   - ${branch}`));
+
+      const proceed = await new Promise((resolve) =>
+        rl.question("\nDo you want to proceed anyway? (y/N): ", resolve)
+      );
+
+      if (proceed.toLowerCase() !== "y") {
+        throw new Error("Operation cancelled by user");
+      }
+    }
+  } catch (error) {
+    if (error.message === "Operation cancelled by user") {
+      throw error;
+    }
+    throw new Error("Failed to validate version availability");
+  }
+};
+
+// Calculate the next version based on type
+const getNextVersion = (currentVersion, type) => {
+  // Strip any pre-release tags (e.g., -staging.0) and split version
+  const baseVersion = currentVersion.split("-")[0];
+  const [major, minor, patch] = baseVersion.split(".").map(Number);
+
+  switch (type) {
+    case "major":
+      return `${major + 1}.0.0`;
+    case "minor":
+      return `${major}.${minor + 1}.0`;
+    case "patch":
+      return `${major}.${minor}.${patch + 1}`;
+    default:
+      throw new Error("Invalid version type");
+  }
+};
+
+// Get unmerged release branches
+const getUnmergedReleaseBranches = () => {
+  try {
+    return execSync("git branch -r")
+      .toString()
+      .split("\n")
+      .filter((branch) => branch.includes("origin/release/v"))
+      .map((branch) => branch.trim())
+      .filter((branch) => {
+        const version = branch.split("/v")[1];
+        return semver.gt(version, getLatestMainVersion());
+      });
+  } catch (error) {
+    return [];
+  }
+};
+
+// Get unmerged feature branches for a version
+const getUnmergedFeatureBranches = (version) => {
+  return execSync("git branch -r")
+    .toString()
+    .split("\n")
+    .filter((branch) => branch.includes(`feature/v${version}/`))
+    .map((branch) => branch.trim());
+};
+
+// Get repository URL for PR creation
+const getRepoUrl = () => {
+  const remoteUrl = execSync("git remote get-url origin").toString().trim();
+  return remoteUrl
+    .replace(/\.git$/, "")
+    .replace("git@github.com:", "https://github.com/");
+};
+
+const createBranch = async () => {
+  try {
+    // Set environment variable to allow branch creation
+    process.env.BRANCH_CREATION_ALLOWED = "true";
+
+    // Ensure we have latest changes
+    console.log("\n📡 Fetching latest changes...");
+    execSync("git fetch origin --quiet");
+
+    // Get target version for new branches
+    const targetVersion = getTargetVersion();
+    const localVersion = require("../package.json").version;
+    const remoteMainVersion = getLatestMainVersion();
+
+    // Only check if we're on main
+    const currentBranch = execSync("git rev-parse --abbrev-ref HEAD")
+      .toString()
+      .trim();
+    if (currentBranch === "main") {
+      if (semver.lt(localVersion, remoteMainVersion)) {
+        throw new Error(
+          `Your local branch (${localVersion}) is behind remote main (${remoteMainVersion}). ` +
+            `Please pull latest changes first: git pull origin main`
+        );
+      }
+    }
+
+    console.log("\nCurrent version:", localVersion);
+
+    console.log("\nSelect branch type:");
+    console.log("1. Feature branch");
+    console.log("2. Release branch");
+    console.log("3. Hotfix branch");
+
+    const answer = await new Promise((resolve) =>
+      rl.question("\nEnter your choice (1, 2 or 3): ", resolve)
+    );
+
+    if (answer === "1") {
+      // Feature branch
+      await validateVersionAvailability(targetVersion);
+
+      const featureName = await new Promise((resolve) =>
+        rl.question("\nEnter feature name (use-kebab-case): ", resolve)
+      );
+
+      if (!isValidFeatureName(featureName)) {
+        throw new Error(
+          "Invalid feature name. Use kebab-case (e.g., 'add-chat-widget')"
+        );
+      }
+
+      const branchName = `feature/v${targetVersion}/${featureName}`;
+      execSync(`git checkout -b ${branchName}`);
+      console.log(`\n✅ Successfully created feature branch: ${branchName}`);
+    } else if (answer === "2") {
+      // Release branch
+      console.log("\nCreating release branch for next version...");
+
+      const conflictedBranches = [];
+
+      // Check for unmerged release branches first
+      const unmergedReleases = getUnmergedReleaseBranches();
+      if (unmergedReleases.length > 0) {
+        console.log("\n⚠️  Unmerged release branches found:");
+        unmergedReleases.forEach((branch, index) =>
+          console.log(`${index + 1}. ${branch}`)
+        );
+
+        const proceed = await new Promise((resolve) =>
+          rl.question(
+            "\nWould you like to:\n" +
+              "1. Add features to existing release\n" +
+              "2. Cancel operation\n" +
+              "\nEnter your choice (1 or 2): ",
+            resolve
+          )
+        );
+
+        if (proceed === "1") {
+          const releaseChoice = await new Promise((resolve) =>
+            rl.question("\nSelect release branch number: ", resolve)
+          );
+
+          const selectedRelease = unmergedReleases[parseInt(releaseChoice) - 1];
+          if (!selectedRelease) {
+            throw new Error("Invalid release branch selection");
+          }
+
+          const releaseVersion = selectedRelease.split("/v")[1];
+          const unmergedFeatures = getUnmergedFeatureBranches(releaseVersion);
+
+          if (unmergedFeatures.length === 0) {
+            console.log(
+              "\nNo unmerged feature branches found for this version."
+            );
+            return;
+          }
+
+          console.log("\nUnmerged feature branches:");
+          unmergedFeatures.forEach((branch, index) =>
+            console.log(`${index + 1}. ${branch}`)
+          );
+
+          const featureChoice = await new Promise((resolve) =>
+            rl.question(
+              "\nSelect features to merge (comma-separated numbers or 'all'): ",
+              resolve
+            )
+          );
+
+          // Checkout the release branch
+          execSync(`git fetch origin ${selectedRelease}`);
+          execSync(
+            `git checkout -b ${selectedRelease.split("origin/")[1]} ${selectedRelease}`
+          );
+
+          // Merge selected features
+          const selectedFeatures =
+            featureChoice.toLowerCase() === "all"
+              ? unmergedFeatures
+              : featureChoice
+                  .split(",")
+                  .map((num) => unmergedFeatures[parseInt(num.trim()) - 1])
+                  .filter(Boolean);
+
+          for (const branch of selectedFeatures) {
+            console.log(`\nMerging ${branch}...`);
+            try {
+              execSync(
+                `git merge ${branch} --no-ff -m "Merge ${branch} into ${branchName}"`
+              );
+            } catch (error) {
+              console.log(`\n⚠️  Merge conflict detected with ${branch}!`);
+              execSync("git merge --abort");
+              console.log(`\n⏩ Skipping ${branch} due to conflicts`);
+              conflictedBranches.push(branch);
+            }
+          }
+
+          // After all merges, show summary of conflicted branches
+          if (conflictedBranches.length > 0) {
+            const repoUrl = getRepoUrl();
+            console.log("\n🚨 MERGE CONFLICTS DETECTED 🚨");
+            console.log("=====================================");
+            conflictedBranches.forEach((branch) => {
+              const prUrl = `${repoUrl}/compare/${branchName}...${branch}?expand=1`;
+              console.log(`\n❌ ${branch}`);
+              console.log(`🔗 Create PR: ${prUrl}`);
+            });
+            console.log(
+              "\n⚠️  ACTION REQUIRED: Please resolve conflicts and merge these branches manually ⚠️"
+            );
+          }
+
+          // Show success message with merged/unmerged counts
+          const mergedCount =
+            selectedFeatures.length - conflictedBranches.length;
+          console.log(
+            `\n✅ Successfully merged ${mergedCount}/${selectedFeatures.length} branches`
+          );
+          if (conflictedBranches.length > 0) {
+            console.log(
+              `\n🚨 ATTENTION: ${conflictedBranches.length} branches require manual conflict resolution 🚨`
+            );
+          }
+
+          return;
+        }
+
+        throw new Error(
+          "Operation cancelled - please merge existing release first"
+        );
+      }
+
+      // Ask for version type
+      console.log("\nSelect version type:");
+      console.log(`1. Major (${getNextVersion(localVersion, "major")})`);
+      console.log(`2. Minor (${getNextVersion(localVersion, "minor")})`);
+      console.log(`3. Patch (${getNextVersion(localVersion, "patch")})`);
+
+      const versionType = await new Promise((resolve) =>
+        rl.question("\nEnter your choice (1, 2 or 3): ", resolve)
+      );
+
+      let releaseVersion;
+      switch (versionType) {
+        case "1":
+          releaseVersion = getNextVersion(localVersion, "major");
+          break;
+        case "2":
+          releaseVersion = getNextVersion(localVersion, "minor");
+          break;
+        case "3":
+          releaseVersion = getNextVersion(localVersion, "patch");
+          break;
+        default:
+          throw new Error("Invalid version type selection");
+      }
+
+      console.log(`\nUpdating package.json version to ${releaseVersion}...`);
+
+      // Create release branch
+      const branchName = `release/v${releaseVersion}`;
+
+      // Check if branch exists remotely
+      const remoteBranches = execSync("git ls-remote --heads origin")
+        .toString()
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => line.split("/").slice(2).join("/"));
+
+      const branchExists = remoteBranches.includes(branchName);
+
+      if (branchExists) {
+        const proceed = await new Promise((resolve) =>
+          rl.question(
+            "\n⚠️  Release branch already exists remotely. Do you want to:\n" +
+              "1. Create new branch with force push (overwrite remote)\n" +
+              "2. Checkout existing branch and continue\n" +
+              "3. Cancel operation\n" +
+              "\nEnter your choice (1, 2 or 3): ",
+            resolve
+          )
+        );
+
+        switch (proceed) {
+          case "1":
+            // Continue with force push
+            break;
+          case "2":
+            execSync(`git fetch origin ${branchName}`);
+            execSync(`git checkout -b ${branchName} origin/${branchName}`);
+            console.log(`\n✅ Checked out existing branch: ${branchName}`);
+            return;
+          default:
+            throw new Error("Operation cancelled by user");
+        }
+      }
+
+      execSync(`git checkout -b ${branchName}`);
+
+      // Update version and commit
+      execSync(`npm version ${releaseVersion} --no-git-tag-version`);
+      execSync(`git add package.json package-lock.json`);
+      execSync(`git commit -m "chore: update version to ${releaseVersion}"`);
+
+      // Set up tracking and push to remote
+      try {
+        console.log("\n📡 Pushing to remote...");
+        execSync(
+          `git push -u origin ${branchName}${branchExists ? " --force" : ""}`
+        );
+      } catch (error) {
+        throw new Error(
+          `Failed to push to remote. Please check your permissions and try again.\nError: ${error.message}`
+        );
+      }
+
+      // Get all feature branches for next version
+      const featureBranches = execSync("git branch -r")
+        .toString()
+        .split("\n")
+        .filter((branch) => branch.includes(`feature/v${releaseVersion}/`))
+        .map((branch) => branch.trim());
+
+      if (featureBranches.length === 0) {
+        console.log("\n⚠️  No feature branches found for this version.");
+        const proceed = await new Promise((resolve) =>
+          rl.question("\nContinue without feature branches? (y/N): ", resolve)
+        );
+        if (proceed.toLowerCase() !== "y") {
+          throw new Error("Operation cancelled by user");
+        }
+      } else {
+        console.log("\nAvailable feature branches:");
+        featureBranches.forEach((branch, index) =>
+          console.log(`${index + 1}. ${branch}`)
+        );
+
+        const featureChoice = await new Promise((resolve) =>
+          rl.question(
+            "\nSelect features to include (comma-separated numbers or 'all' or 'none'): ",
+            resolve
+          )
+        );
+
+        // Treat empty input as "none"
+        const choice = featureChoice.trim().toLowerCase();
+        const isNoneOrEmpty = !choice || choice === "none";
+
+        if (!isNoneOrEmpty) {
+          const selectedFeatures =
+            choice === "all"
+              ? featureBranches
+              : choice
+                  .split(",")
+                  .map((num) => featureBranches[parseInt(num.trim()) - 1])
+                  .filter(Boolean);
+
+          // Validate that we have valid selections
+          if (selectedFeatures.length === 0) {
+            throw new Error(
+              "No valid feature branches selected. Please try again"
+            );
+          }
+
+          // Merge selected feature branches
+          for (const branch of selectedFeatures) {
+            console.log(`\nMerging ${branch}...`);
+            try {
+              execSync(
+                `git merge ${branch} --no-ff -m "Merge ${branch} into ${branchName}"`
+              );
+            } catch (error) {
+              console.log(`\n⚠️  Merge conflict detected with ${branch}!`);
+              execSync("git merge --abort");
+              console.log(`\n⏩ Skipping ${branch} due to conflicts`);
+              conflictedBranches.push(branch);
+            }
+          }
+
+          // After all merges, show summary of conflicted branches
+          if (conflictedBranches.length > 0) {
+            const repoUrl = getRepoUrl();
+            console.log("\n🚨 MERGE CONFLICTS DETECTED 🚨");
+            console.log("=====================================");
+            conflictedBranches.forEach((branch) => {
+              const prUrl = `${repoUrl}/compare/${branchName}...${branch}?expand=1`;
+              console.log(`\n❌ ${branch}`);
+              console.log(`🔗 Create PR: ${prUrl}`);
+            });
+            console.log(
+              "\n⚠️  ACTION REQUIRED: Please resolve conflicts and merge these branches manually ⚠️"
+            );
+          }
+
+          // Show success message with merged/unmerged counts
+          const mergedCount =
+            selectedFeatures.length - conflictedBranches.length;
+          console.log(
+            `\n✅ Successfully merged ${mergedCount}/${selectedFeatures.length} branches`
+          );
+          if (conflictedBranches.length > 0) {
+            console.log(
+              `\n🚨 ATTENTION: ${conflictedBranches.length} branches require manual conflict resolution 🚨`
+            );
+          }
+        } else {
+          console.log("\n📝 Creating release branch without features");
+        }
+      }
+
+      // Push all changes to remote
+      try {
+        console.log("\n📡 Pushing final changes to remote...");
+        execSync(`git push origin ${branchName}`);
+      } catch (error) {
+        throw new Error(
+          `Failed to push final changes. Please push manually.\nError: ${error.message}`
+        );
+      }
+
+      console.log(`\n✅ Successfully created release branch: ${branchName}`);
+      console.log("\nNext steps:");
+      console.log("1. Review and test the changes");
+      console.log("2. Run 'npm run publish:production' when ready to release");
+    } else if (answer === "3") {
+      // Hotfix branch
+      console.log("\nEnter the version to hotfix (e.g., 1.1.14):");
+      const targetVersion = await new Promise((resolve) =>
+        rl.question("\nVersion: ", resolve)
+      );
+
+      // Validate version format
+      if (!/^\d+\.\d+\.\d+$/.test(targetVersion)) {
+        throw new Error("Invalid version format. Use semver (e.g., 1.1.14)");
+      }
+
+      // Get patch number
+      console.log("\nEnter patch number (e.g., 1 for first patch):");
+      const patchNumber = await new Promise((resolve) =>
+        rl.question("\nPatch number: ", resolve)
+      );
+
+      if (!/^\d+$/.test(patchNumber)) {
+        throw new Error("Invalid patch number. Use a number (e.g., 1)");
+      }
+
+      const branchName = `hotfix/v${targetVersion}-patch.${patchNumber}`;
+
+      // Checkout the tag first
+      execSync(`git fetch --all --tags`);
+      execSync(`git checkout v${targetVersion}`);
+      execSync(`git checkout -b ${branchName}`);
+
+      console.log(`\n✅ Successfully created hotfix branch: ${branchName}`);
+    } else {
+      throw new Error("Invalid choice. Please select 1, 2 or 3.");
+    }
+  } catch (error) {
+    console.error("\n❌ Error:", error.message);
+  } finally {
+    // Clear the environment variable
+    delete process.env.BRANCH_CREATION_ALLOWED;
+
+    rl.close();
+  }
+};
+
+createBranch();

package/scripts/create-version-tag.js

@@ -0,0 +1,29 @@
+const { execSync } = require("child_process");
+
+const createVersionTag = () => {
+  try {
+    const { version } = require("../package.json");
+    const tagName = `v${version}`;
+
+    // Check if tag exists
+    try {
+      execSync(`git tag -l "${tagName}"`).toString().trim();
+      console.log(`✅ Tag ${tagName} already exists, skipping tag creation`);
+      return;
+    } catch (error) {
+      // Tag doesn't exist, create it
+      try {
+        execSync(`git tag -a ${tagName} -m "Release: ${tagName}"`);
+        execSync(`git push origin ${tagName}`);
+        console.log(`✅ Successfully created and pushed tag: ${tagName}`);
+      } catch (tagError) {
+        throw new Error(`Failed to create or push tag: ${tagError.message}`);
+      }
+    }
+  } catch (error) {
+    console.error("\n❌ Error creating tag:", error.message);
+    process.exit(1);
+  }
+};
+
+createVersionTag();

package/scripts/get-next-version.js

@@ -0,0 +1,29 @@
+const semver = require("semver");
+const { execSync } = require("child_process");
+
+function getNextVersion(publishType) {
+  const { version } = require("../package.json");
+
+  switch (publishType) {
+    case "staging":
+      return semver.inc(version, "prerelease", "staging");
+    case "hotfix":
+      return semver.inc(version, "prerelease", "patch");
+    case "production":
+      return semver.inc(version, "patch");
+    default:
+      throw new Error(`Invalid publish type: ${publishType}`);
+  }
+}
+
+// If script is run directly
+if (require.main === module) {
+  const publishType = process.argv[2];
+  if (!publishType) {
+    console.error("Please provide a publish type (staging|production|hotfix)");
+    process.exit(1);
+  }
+  console.log(getNextVersion(publishType));
+}
+
+module.exports = getNextVersion;

package/scripts/husky-setup.js

@@ -0,0 +1,32 @@
+const { execSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+
+// Initialize husky
+execSync("npx husky install");
+
+// Create .husky directory if it doesn't exist
+const huskyDir = path.join(__dirname, "../.husky");
+if (!fs.existsSync(huskyDir)) {
+  fs.mkdirSync(huskyDir, { recursive: true });
+}
+
+// Create commit-msg hook
+const hookContent = `#!/bin/sh
+
+sh scripts/validate-branch-name.sh
+`;
+
+fs.writeFileSync(path.join(huskyDir, "commit-msg"), hookContent);
+fs.chmodSync(path.join(huskyDir, "commit-msg"), "755");
+
+// Create post-checkout hook to prevent direct branch creation
+const postCheckoutContent = `#!/bin/sh
+
+node scripts/prevent-direct-branch.js
+`;
+
+fs.writeFileSync(path.join(huskyDir, "post-checkout"), postCheckoutContent);
+fs.chmodSync(path.join(huskyDir, "post-checkout"), "755");
+
+console.log("Husky hooks installed successfully!");

package/scripts/prevent-direct-branch.js

@@ -0,0 +1,37 @@
+const { execSync } = require("child_process");
+
+// Get command line arguments passed by Git
+// In post-checkout hook, Git passes 3 arguments:
+// 1. Previous HEAD ref
+// 2. New HEAD ref
+// 3. Flag (1 for branch checkout, 0 for file checkout)
+const [prevHead, newHead, checkoutFlag] = process.argv.slice(2);
+
+try {
+  // Get the current branch name
+  const currentBranch = execSync("git rev-parse --abbrev-ref HEAD")
+    .toString()
+    .trim();
+
+  // Only check for branch creation (when prevHead and newHead are different and checkoutFlag is 1)
+  const isBranchCreation = prevHead !== newHead && checkoutFlag === "1";
+
+  // Check if this was a direct branch creation
+  if (
+    isBranchCreation && // Only check actual branch creation
+    !currentBranch.includes("temp-version-update")
+  ) {
+    // If we moved from one branch to a new one, it was likely created directly
+    if (!process.env.BRANCH_CREATION_ALLOWED) {
+      console.error("\n❌ Direct branch creation is not allowed.");
+      console.error("Please use: npm run branch");
+      console.error(
+        "This ensures proper version control and naming conventions."
+      );
+      process.exit(1);
+    }
+  }
+} catch (error) {
+  // If we can't determine, let it pass
+  process.exit(0);
+}

package/scripts/publish-version.js

@@ -0,0 +1,13 @@
+const { execSync } = require("child_process");
+
+// Get current branch name
+const branch = execSync("git rev-parse --abbrev-ref HEAD").toString().trim();
+
+// If we're on a release branch, don't increment version
+if (branch.startsWith("release/v")) {
+  console.log("On release branch - skipping version increment");
+  process.exit(0);
+} else {
+  // For other branches, increment patch version
+  execSync("npm version patch", { stdio: "inherit" });
+}

package/scripts/release.js

@@ -0,0 +1,77 @@
+const { execSync } = require("child_process");
+const readline = require("readline");
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+const release = async () => {
+  try {
+    // 1. Validate current branch is a release branch
+    const currentBranch = execSync("git rev-parse --abbrev-ref HEAD")
+      .toString()
+      .trim();
+
+    if (!currentBranch.startsWith("release/v")) {
+      throw new Error(
+        "Release process must be started from a release branch.\n" +
+          `Current branch: ${currentBranch}\n` +
+          "Expected format: release/v{version}"
+      );
+    }
+
+    // 2. Check if version is already published
+    const version = currentBranch.split("/v")[1];
+    const publishedVersions = execSync(
+      "npm view @robylon/web-react-sdk versions --json"
+    ).toString();
+
+    if (publishedVersions.includes(version)) {
+      throw new Error(
+        `Version ${version} is already published to npm.\n` +
+          "Please create a new release branch with a different version."
+      );
+    }
+
+    // 3. Confirm release process
+    console.log("\n📦 Starting release process for version", version);
+    console.log("\nThis will:");
+    console.log("1. Publish to npm");
+    console.log("2. Create git tag");
+    console.log("3. Merge to main");
+
+    const proceed = await new Promise((resolve) =>
+      rl.question("\nProceed with release? (y/N): ", resolve)
+    );
+
+    if (proceed.toLowerCase() !== "y") {
+      throw new Error("Release cancelled by user");
+    }
+
+    // 4. Run publish
+    console.log("\n🚀 Publishing to npm...");
+    execSync("npm run publish:production", { stdio: "inherit" });
+
+    // 5. Merge to main
+    console.log("\n🔄 Merging to main...");
+    execSync("git checkout main");
+    execSync("git pull origin main");
+    execSync(
+      `git merge ${currentBranch} --no-ff -m "chore: release version ${version}"`
+    );
+    execSync("git push origin main");
+
+    console.log("\n✅ Release completed successfully!");
+    console.log(`Version ${version} is now available on npm`);
+    console.log("Changes have been merged to main");
+  } catch (error) {
+    console.error("\n❌ Release failed:");
+    console.error(error.message);
+    process.exit(1);
+  } finally {
+    rl.close();
+  }
+};
+
+release();

package/scripts/setup-git-hooks.js

@@ -0,0 +1,18 @@
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+
+// Create .git/hooks directory if it doesn't exist
+const hooksDir = path.join(__dirname, "../.git/hooks");
+if (!fs.existsSync(hooksDir)) {
+  fs.mkdirSync(hooksDir, { recursive: true });
+}
+
+// Copy the validate-branch-name script
+const sourcePath = path.join(__dirname, "validate-branch-name.sh");
+const targetPath = path.join(hooksDir, "commit-msg");
+
+fs.copyFileSync(sourcePath, targetPath);
+fs.chmodSync(targetPath, "755");
+
+console.log("Git hooks installed successfully!");

package/scripts/validate-branch-name.sh

@@ -0,0 +1,65 @@
+#!/bin/bash
+
+echo "DEBUG: Script executed from: $0"
+echo "DEBUG: PWD: $(pwd)"
+
+# Get the full version including staging suffix if present
+FULL_VERSION=$(node -p "require('./package.json').version")
+
+# Check if this is a staging version before any other operations
+if [[ $FULL_VERSION == *"-staging."* ]]; then
+  echo "Staging version detected. Skipping branch name validation."
+  exit 0
+fi
+
+# Get base version without pre-release tags (e.g., 1.1.14 from 1.1.14-staging.0)
+BASE_VERSION=$(echo $FULL_VERSION | cut -d'-' -f1)
+
+# Get the branch name
+BRANCH_NAME=$(git rev-parse --abbrev-ref HEAD)
+
+# Get latest published version from npm
+LATEST_VERSION=$(npm view @robylon/web-react-sdk version 2>/dev/null || echo "0.0.0")
+
+# Regular expression for valid branch names
+FEATURE_PATTERN="^feature/v[0-9]+\.[0-9]+\.[0-9]+/[a-z0-9-]+$"
+RELEASE_PATTERN="^release/v${BASE_VERSION}$"
+HOTFIX_PATTERN="^hotfix/v[0-9]+\.[0-9]+\.[0-9]+(-patch\.[0-9]+)?$"
+
+echo "Validating branch: $BRANCH_NAME"
+echo "Current version: $BASE_VERSION"
+echo "Latest published version: $LATEST_VERSION"
+
+# For release branches, ensure version matches branch exactly
+if [[ $BRANCH_NAME =~ ^release/v ]]; then
+    # Extract version from branch name
+    BRANCH_VERSION=$(echo $BRANCH_NAME | sed 's/release\/v//')
+    
+    # Check if branch version matches package version
+    if [[ "$BRANCH_VERSION" != "$BASE_VERSION" ]]; then
+        echo "Error: Release branch version ($BRANCH_VERSION) must match package.json version ($BASE_VERSION)"
+        exit 1
+    fi
+    
+    # Check if trying to publish a version behind latest
+    if [[ $(node -p "require('semver').lt('$BASE_VERSION', '$LATEST_VERSION')") == "true" ]]; then
+        echo "Error: Cannot publish version $BASE_VERSION as it is behind the latest published version $LATEST_VERSION"
+        exit 1
+    fi
+    
+    echo "✅ Valid release branch name and version"
+    exit 0
+fi
+
+# Validate other branch types
+if [[ $BRANCH_NAME =~ $FEATURE_PATTERN ]] || [[ $BRANCH_NAME =~ $HOTFIX_PATTERN ]]; then
+    echo "✅ Valid branch name"
+    exit 0
+else
+    echo "Error: Invalid branch name format."
+    echo "Branch names must follow these formats:"
+    echo "- For feature branches: feature/v{version}/{feature-name}"
+    echo "- For release branches: release/v{version}"
+    echo "- For hotfix branches: hotfix/v{version}-patch.{number}"
+    exit 1
+fi

package/scripts/validate-publish.js

@@ -0,0 +1,71 @@
+const { execSync } = require("child_process");
+
+const validatePublish = (type) => {
+  try {
+    // Get current branch
+    const currentBranch = execSync("git rev-parse --abbrev-ref HEAD")
+      .toString()
+      .trim();
+
+    // Get version from package.json
+    const { version } = require("../package.json");
+    const baseVersion = version.split("-")[0];
+
+    switch (type) {
+      case "production":
+        if (!currentBranch.startsWith("release/v")) {
+          throw new Error(
+            "Production publishing is only allowed from release branches.\n" +
+              "Current branch: " +
+              currentBranch +
+              "\n" +
+              "Expected format: release/v{version}"
+          );
+        }
+
+        // Verify release branch version matches package version
+        const releaseBranchVersion = currentBranch.split("/v")[1];
+        if (releaseBranchVersion !== baseVersion) {
+          throw new Error(
+            "Release branch version does not match package.json version.\n" +
+              `Branch version: ${releaseBranchVersion}\n` +
+              `Package version: ${baseVersion}\n` +
+              "Please update package.json version to match the release branch"
+          );
+        }
+        break;
+
+      case "hotfix":
+        if (!currentBranch.startsWith("hotfix/v")) {
+          throw new Error(
+            "Hotfix publishing is only allowed from hotfix branches.\n" +
+              "Current branch: " +
+              currentBranch +
+              "\n" +
+              "Expected format: hotfix/v{version}-patch.{number}"
+          );
+        }
+        break;
+
+      case "staging":
+        if (!currentBranch.startsWith("feature/v")) {
+          throw new Error(
+            "Staging publishing is only allowed from feature branches.\n" +
+              "Current branch: " +
+              currentBranch +
+              "\n" +
+              "Expected format: feature/v{version}/{feature-name}"
+          );
+        }
+        break;
+    }
+  } catch (error) {
+    console.error("\n❌ Publish validation failed:");
+    console.error(error.message);
+    process.exit(1);
+  }
+};
+
+// Get publish type from command line argument
+const publishType = process.argv[2];
+validatePublish(publishType);

package/scripts/generate-version.js

@@ -1,9 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-const package = require("../package.json");
-
-const content = `// This file is auto-generated. Do not modify it manually.
-export const SDK_VERSION = '${package.version}';
-`;
-
-fs.writeFileSync(path.join(__dirname, "../src/version.ts"), content);