hale-commenting-system 2.2.0 → 2.2.2

package/scripts/integrate.js

@@ -0,0 +1,472 @@
+#!/usr/bin/env node
+
+/**
+ * Hale Commenting System - Auto Integration Script
+ * 
+ * This script automatically integrates the commenting system into a PatternFly React Seed project
+ * by modifying the necessary files using AST parsing.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+// Check if required dependencies are available
+let parser, traverse, generate, types;
+try {
+  const babel = require('@babel/core');
+  parser = babel.parse;
+  traverse = require('@babel/traverse').default;
+  generate = require('@babel/generator').default;
+  types = require('@babel/types');
+} catch (e) {
+  console.error('❌ Error: @babel/core, @babel/traverse, and @babel/generator are required.');
+  console.error('   Please install: npm install --save-dev @babel/core @babel/traverse @babel/generator @babel/types');
+  process.exit(1);
+}
+
+const readline = require('readline');
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+function question(prompt) {
+  return new Promise((resolve) => {
+    rl.question(prompt, resolve);
+  });
+}
+
+function findFile(filename, startDir = process.cwd()) {
+  const possiblePaths = [
+    path.join(startDir, filename),
+    path.join(startDir, 'src', filename),
+    path.join(startDir, 'src', 'app', filename),
+    // Support for AppLayout subdirectory
+    path.join(startDir, 'src', 'app', 'AppLayout', filename),
+  ];
+
+  for (const filePath of possiblePaths) {
+    if (fs.existsSync(filePath)) {
+      return filePath;
+    }
+  }
+  return null;
+}
+
+function getPackageVersion() {
+  try {
+    // Get the script's directory and find package.json relative to it
+    const scriptDir = __dirname || path.dirname(require.resolve('./integrate.js'));
+    const packageJsonPath = path.join(scriptDir, '..', 'package.json');
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    return packageJson.version || 'unknown';
+  } catch (e) {
+    // Fallback: try to find package.json in current working directory or parent
+    try {
+      const cwdPackageJson = path.join(process.cwd(), 'package.json');
+      if (fs.existsSync(cwdPackageJson)) {
+        const packageJson = JSON.parse(fs.readFileSync(cwdPackageJson, 'utf8'));
+        if (packageJson.name === 'hale-commenting-system') {
+          return packageJson.version || 'unknown';
+        }
+      }
+    } catch (e2) {
+      // ignore
+    }
+    return 'unknown';
+  }
+}
+
+function modifyIndexTsx(filePath) {
+  const content = fs.readFileSync(filePath, 'utf8');
+  
+  // Check if already integrated
+  if (content.includes('CommentProvider') && content.includes('GitHubAuthProvider')) {
+    console.log('   ⚠️  Already integrated (providers found)');
+    return false;
+  }
+
+  try {
+    const ast = parser(content, {
+      sourceType: 'module',
+      plugins: ['typescript', 'jsx', 'decorators-legacy', 'classProperties']
+    });
+
+    let hasCommentProvider = false;
+    let hasGitHubAuthProvider = false;
+    let hasCommentImport = false;
+    let routerElement = null;
+
+    // Check existing imports and find Router element
+    traverse(ast, {
+      ImportDeclaration(path) {
+        const source = path.node.source.value;
+        if (source.includes('commenting-system') || source.includes('@app/commenting-system')) {
+          hasCommentImport = true;
+          // Check if providers are imported
+          path.node.specifiers.forEach(spec => {
+            if (spec.imported && spec.imported.name === 'CommentProvider') {
+              hasCommentProvider = true;
+            }
+            if (spec.imported && spec.imported.name === 'GitHubAuthProvider') {
+              hasGitHubAuthProvider = true;
+            }
+          });
+        }
+      },
+      JSXElement(path) {
+        if (path.node.openingElement.name.name === 'Router') {
+          routerElement = path;
+        }
+      }
+    });
+
+    // Add imports if missing
+    if (!hasCommentImport) {
+      // Find last import declaration
+      let lastImportIndex = -1;
+      for (let i = ast.program.body.length - 1; i >= 0; i--) {
+        if (ast.program.body[i].type === 'ImportDeclaration') {
+          lastImportIndex = i;
+          break;
+        }
+      }
+      const importIndex = lastImportIndex >= 0 ? lastImportIndex + 1 : 0;
+      
+      const providerImports = types.importDeclaration(
+        [
+          types.importSpecifier(types.identifier('CommentProvider'), types.identifier('CommentProvider')),
+          types.importSpecifier(types.identifier('GitHubAuthProvider'), types.identifier('GitHubAuthProvider'))
+        ],
+        types.stringLiteral('@app/commenting-system')
+      );
+      
+      ast.program.body.splice(importIndex, 0, providerImports);
+    } else if (!hasCommentProvider || !hasGitHubAuthProvider) {
+      // Update existing import
+      traverse(ast, {
+        ImportDeclaration(path) {
+          const source = path.node.source.value;
+          if (source.includes('commenting-system') || source.includes('@app/commenting-system')) {
+            const specifiers = path.node.specifiers || [];
+            if (!hasCommentProvider) {
+              specifiers.push(types.importSpecifier(types.identifier('CommentProvider'), types.identifier('CommentProvider')));
+            }
+            if (!hasGitHubAuthProvider) {
+              specifiers.push(types.importSpecifier(types.identifier('GitHubAuthProvider'), types.identifier('GitHubAuthProvider')));
+            }
+            path.node.specifiers = specifiers;
+          }
+        }
+      });
+    }
+
+    // Wrap Router content with providers
+    if (routerElement) {
+      const routerChildren = routerElement.node.children;
+      
+      // Check if already wrapped
+      if (routerChildren.length > 0 && 
+          routerChildren[0].type === 'JSXElement' && 
+          routerChildren[0].openingElement.name.name === 'GitHubAuthProvider') {
+        console.log('   ⚠️  Already integrated (providers found in JSX)');
+        return false;
+      }
+
+      // Create provider wrappers
+      const commentProvider = types.jsxElement(
+        types.jsxOpeningElement(types.jsxIdentifier('CommentProvider'), []),
+        types.jsxClosingElement(types.jsxIdentifier('CommentProvider')),
+        routerChildren
+      );
+
+      const gitHubAuthProvider = types.jsxElement(
+        types.jsxOpeningElement(types.jsxIdentifier('GitHubAuthProvider'), []),
+        types.jsxClosingElement(types.jsxIdentifier('GitHubAuthProvider')),
+        [commentProvider]
+      );
+
+      routerElement.node.children = [gitHubAuthProvider];
+    }
+
+    const output = generate(ast, {
+      retainLines: false,
+      compact: false
+    }, content);
+
+    fs.writeFileSync(filePath, output.code);
+    return true;
+  } catch (error) {
+    console.error(`   ❌ Error modifying ${filePath}:`, error.message);
+    return false;
+  }
+}
+
+function modifyRoutesTsx(filePath) {
+  const content = fs.readFileSync(filePath, 'utf8');
+  
+  // Check if Comments route already exists
+  if (content.includes("label: 'Comments'") || content.includes('label: "Comments"')) {
+    console.log('   ⚠️  Already integrated (Comments route found)');
+    return false;
+  }
+
+  try {
+    const ast = parser(content, {
+      sourceType: 'module',
+      plugins: ['typescript', 'jsx', 'decorators-legacy', 'classProperties']
+    });
+
+    let routesArray = null;
+
+    traverse(ast, {
+      VariableDeclarator(path) {
+        if (path.node.id.name === 'routes' && path.node.init.type === 'ArrayExpression') {
+          routesArray = path.node.init;
+        }
+      }
+    });
+
+    if (routesArray) {
+      // Add Comments route group
+      const commentsRoute = types.objectExpression([
+        types.objectProperty(types.identifier('label'), types.stringLiteral('Comments')),
+        types.objectProperty(types.identifier('routes'), types.arrayExpression([]))
+      ]);
+
+      routesArray.elements.push(commentsRoute);
+    }
+
+    const output = generate(ast, {
+      retainLines: false,
+      compact: false
+    }, content);
+
+    fs.writeFileSync(filePath, output.code);
+    return true;
+  } catch (error) {
+    console.error(`   ❌ Error modifying ${filePath}:`, error.message);
+    return false;
+  }
+}
+
+function modifyAppLayoutTsx(filePath) {
+  const content = fs.readFileSync(filePath, 'utf8');
+  
+  // Check if already integrated
+  if (content.includes('CommentPanel') && content.includes('CommentOverlay')) {
+    console.log('   ⚠️  Already integrated (CommentPanel/CommentOverlay found)');
+    return false;
+  }
+
+  try {
+    const ast = parser(content, {
+      sourceType: 'module',
+      plugins: ['typescript', 'jsx', 'decorators-legacy', 'classProperties']
+    });
+
+    let hasCommentImport = false;
+    let pageElement = null;
+
+    // Check imports and find Page element
+    traverse(ast, {
+      ImportDeclaration(path) {
+        const source = path.node.source.value;
+        if (source.includes('commenting-system') || source.includes('@app/commenting-system')) {
+          hasCommentImport = true;
+          // Check if components are imported
+          const specifiers = path.node.specifiers || [];
+          const hasCommentPanel = specifiers.some(s => 
+            s.imported && (s.imported.name === 'CommentPanel' || s.local.name === 'CommentPanel')
+          );
+          const hasCommentOverlay = specifiers.some(s => 
+            s.imported && (s.imported.name === 'CommentOverlay' || s.local.name === 'CommentOverlay')
+          );
+
+          if (!hasCommentPanel) {
+            specifiers.push(types.importSpecifier(types.identifier('CommentPanel'), types.identifier('CommentPanel')));
+          }
+          if (!hasCommentOverlay) {
+            specifiers.push(types.importSpecifier(types.identifier('CommentOverlay'), types.identifier('CommentOverlay')));
+          }
+          path.node.specifiers = specifiers;
+        }
+      },
+      JSXElement(path) {
+        if (path.node.openingElement.name.name === 'Page') {
+          pageElement = path;
+        }
+      }
+    });
+
+    // Add imports if missing
+    if (!hasCommentImport) {
+      // Find last import declaration
+      let lastImportIndex = -1;
+      for (let i = ast.program.body.length - 1; i >= 0; i--) {
+        if (ast.program.body[i].type === 'ImportDeclaration') {
+          lastImportIndex = i;
+          break;
+        }
+      }
+      const importIndex = lastImportIndex >= 0 ? lastImportIndex + 1 : 0;
+      
+      const componentImports = types.importDeclaration(
+        [
+          types.importSpecifier(types.identifier('CommentPanel'), types.identifier('CommentPanel')),
+          types.importSpecifier(types.identifier('CommentOverlay'), types.identifier('CommentOverlay'))
+        ],
+        types.stringLiteral('@app/commenting-system')
+      );
+      
+      ast.program.body.splice(importIndex, 0, componentImports);
+    }
+
+    // Wrap Page children with CommentPanel and CommentOverlay
+    if (pageElement) {
+      const pageChildren = pageElement.node.children;
+      
+      // Check if already wrapped
+      if (pageChildren.length > 0 && 
+          pageChildren[0].type === 'JSXElement' && 
+          pageChildren[0].openingElement.name.name === 'CommentPanel') {
+        console.log('   ⚠️  Already integrated (CommentPanel found in JSX)');
+        return false;
+      }
+
+      // Create CommentOverlay
+      const commentOverlay = types.jsxElement(
+        types.jsxOpeningElement(types.jsxIdentifier('CommentOverlay'), [], true),
+        null,
+        []
+      );
+
+      // Create CommentPanel wrapping children and CommentOverlay
+      const commentPanel = types.jsxElement(
+        types.jsxOpeningElement(types.jsxIdentifier('CommentPanel'), []),
+        types.jsxClosingElement(types.jsxIdentifier('CommentPanel')),
+        [commentOverlay, ...pageChildren]
+      );
+
+      pageElement.node.children = [commentPanel];
+    }
+
+    const output = generate(ast, {
+      retainLines: false,
+      compact: false
+    }, content);
+
+    fs.writeFileSync(filePath, output.code);
+    return true;
+  } catch (error) {
+    console.error(`   ❌ Error modifying ${filePath}:`, error.message);
+    return false;
+  }
+}
+
+async function main() {
+  const version = getPackageVersion();
+  const title = `Hale Commenting System (v.${version})`;
+  const titleLength = title.length;
+  const borderLength = Math.max(titleLength + 4, 54);
+  const padding = Math.floor((borderLength - titleLength - 2) / 2);
+  
+  console.log('\n' + '╔' + '═'.repeat(borderLength - 2) + '╗');
+  console.log('║' + ' '.repeat(padding) + title + ' '.repeat(borderLength - titleLength - padding - 2) + '║');
+  console.log('╚' + '═'.repeat(borderLength - 2) + '╝\n');
+
+  console.log('We\'ll automatically integrate the commenting system into your project.\n');
+  console.log('This will modify the following files:');
+  console.log('  • src/app/index.tsx');
+  console.log('  • src/app/routes.tsx');
+  console.log('  • src/app/AppLayout/AppLayout.tsx\n');
+
+  const answer = await question('Continue? (Y/n) ');
+
+  if (answer.toLowerCase() !== 'y' && answer.toLowerCase() !== '' && answer.toLowerCase() !== 'yes') {
+    console.log('\n❌ Integration cancelled.');
+    rl.close();
+    return;
+  }
+
+  console.log('\n✓ Scanning project structure...');
+
+  const indexPath = findFile('index.tsx');
+  const routesPath = findFile('routes.tsx');
+  const appLayoutPath = findFile('AppLayout/AppLayout.tsx') || findFile('AppLayout.tsx');
+
+  if (!indexPath) {
+    console.error('❌ Could not find src/app/index.tsx');
+    rl.close();
+    process.exit(1);
+  }
+  if (!routesPath) {
+    console.error('❌ Could not find src/app/routes.tsx');
+    rl.close();
+    process.exit(1);
+  }
+  if (!appLayoutPath) {
+    console.error('❌ Could not find src/app/AppLayout/AppLayout.tsx');
+    rl.close();
+    process.exit(1);
+  }
+
+  console.log('✓ Modifying files...\n');
+
+  let successCount = 0;
+  let skippedCount = 0;
+
+  // Modify index.tsx
+  console.log(`📝 ${indexPath}`);
+  if (modifyIndexTsx(indexPath)) {
+    console.log('   ✅ Added providers');
+    successCount++;
+  } else {
+    skippedCount++;
+  }
+
+  // Modify routes.tsx
+  console.log(`\n📝 ${routesPath}`);
+  if (modifyRoutesTsx(routesPath)) {
+    console.log('   ✅ Added Comments route');
+    successCount++;
+  } else {
+    skippedCount++;
+  }
+
+  // Modify AppLayout.tsx
+  console.log(`\n📝 ${appLayoutPath}`);
+  if (modifyAppLayoutTsx(appLayoutPath)) {
+    console.log('   ✅ Added CommentPanel and CommentOverlay');
+    successCount++;
+  } else {
+    skippedCount++;
+  }
+
+  console.log('\n╔══════════════════════════════════════════════════════════╗');
+  console.log('║   ✅ Integration Complete!                                 ║');
+  console.log('╚══════════════════════════════════════════════════════════╝\n');
+
+  if (successCount > 0) {
+    console.log(`✓ Modified ${successCount} file(s)`);
+  }
+  if (skippedCount > 0) {
+    console.log(`⚠️  ${skippedCount} file(s) already integrated or skipped`);
+  }
+
+  console.log('\nNext steps:');
+  console.log('  1. Restart your dev server: npm run start:dev');
+  console.log('  2. The commenting system will be active automatically');
+  console.log('  3. Click anywhere on the page to create comments\n');
+
+  rl.close();
+}
+
+main().catch((error) => {
+  console.error('\n❌ Integration failed:', error.message);
+  rl.close();
+  process.exit(1);
+});
+