@raclettejs/core 0.0.1

package/services/frontend/src/orchestrator/scripts/analyseBundleComponents.js

@@ -0,0 +1,243 @@
+/**
+ * Bundle Component Analyzer
+ * Analyzes the built bundle to see which components are actually included
+ */
+
+import fs from "fs"
+import path from "path"
+import { fileURLToPath } from "url"
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+const DIST_DIR = path.join(__dirname, "../dist")
+const ASSETS_DIR = path.join(DIST_DIR, "assets")
+
+/**
+ * Read all JS files from dist/assets
+ */
+const readBundleFiles = () => {
+  if (!fs.existsSync(ASSETS_DIR)) {
+    console.error("❌ Dist directory not found. Run `npm run build` first.")
+
+    return []
+  }
+
+  const files = fs.readdirSync(ASSETS_DIR)
+  const jsFiles = files.filter((file) => file.endsWith(".js"))
+
+  console.log(`📦 Found ${jsFiles.length} JS bundle files:`)
+  jsFiles.forEach((file) => console.log(`   - ${file}`))
+
+  return jsFiles.map((file) => ({
+    name: file,
+    path: path.join(ASSETS_DIR, file),
+    content: fs.readFileSync(path.join(ASSETS_DIR, file), "utf-8"),
+  }))
+}
+
+/**
+ * Search for Vue component references in bundle
+ */
+const searchForComponent = (bundleFiles, componentName) => {
+  const results = []
+
+  // Different patterns a Vue component might appear as in the bundle
+  const patterns = [
+    new RegExp(`${componentName}`, "gi"),
+    new RegExp(`${componentName}\\.vue`, "gi"),
+    new RegExp(`"${componentName}"`, "gi"),
+    new RegExp(`'${componentName}'`, "gi"),
+    new RegExp(`${componentName.toLowerCase()}`, "gi"),
+    // Vue component compilation patterns
+    new RegExp(`_component_${componentName}`, "gi"),
+    new RegExp(`${componentName}_vue`, "gi"),
+    new RegExp(`__default__.*${componentName}`, "gi"),
+  ]
+
+  bundleFiles.forEach((file) => {
+    patterns.forEach((pattern, index) => {
+      const matches = file.content.match(pattern)
+
+      if (matches) {
+        results.push({
+          file: file.name,
+          pattern: pattern.source,
+          matches: matches.length,
+          firstMatch: matches[0],
+        })
+      }
+    })
+  })
+
+  return results
+}
+
+/**
+ * List all likely Vue component references in bundle
+ */
+const findAllVueComponents = (bundleFiles) => {
+  const componentPatterns = [
+    // Look for .vue file references
+    /[a-zA-Z0-9_-]+\.vue/gi,
+    // Look for Vue component registration patterns
+    /_component_[a-zA-Z0-9_]+/gi,
+    // Look for defineComponent calls
+    /defineComponent\s*\(/gi,
+    // Look for component imports
+    /import.*from.*\.vue/gi,
+  ]
+
+  const allComponents = new Set()
+
+  bundleFiles.forEach((file) => {
+    componentPatterns.forEach((pattern) => {
+      const matches = file.content.match(pattern)
+
+      if (matches) {
+        matches.forEach((match) => allComponents.add(match))
+      }
+    })
+  })
+
+  return Array.from(allComponents)
+}
+
+/**
+ * Check if routes are properly bundled
+ */
+const analyzeRoutes = (bundleFiles) => {
+  const routePatterns = [
+    /ProductOrchestrator/gi,
+    /public_terms/gi,
+    /"app\.space\.page"/gi,
+    /"public\.logout"/gi,
+    /"public\.terms"/gi,
+    /vue-router/gi,
+    /createRouter/gi,
+  ]
+
+  const routeResults = {}
+
+  routePatterns.forEach((pattern) => {
+    const patternName = pattern.source.replace(/[^a-zA-Z0-9]/g, "_")
+
+    routeResults[patternName] = []
+
+    bundleFiles.forEach((file) => {
+      const matches = file.content.match(pattern)
+
+      if (matches) {
+        routeResults[patternName].push({
+          file: file.name,
+          matches: matches.length,
+        })
+      }
+    })
+  })
+
+  return routeResults
+}
+
+/**
+ * Main analysis function
+ */
+const analyzeBundle = () => {
+  console.log("🔍 Analyzing bundle for Vue components...\n")
+
+  const bundleFiles = readBundleFiles()
+
+  if (bundleFiles.length === 0) {
+    return
+  }
+
+  console.log("\n📊 Bundle Analysis Results:")
+  console.log("=====================================")
+
+  // Check for ProductOrchestrator specifically
+  console.log("\n🎭 ProductOrchestrator Analysis:")
+  const orchestratorResults = searchForComponent(
+    bundleFiles,
+    "ProductOrchestrator",
+  )
+
+  if (orchestratorResults.length > 0) {
+    console.log("✅ ProductOrchestrator found in bundle:")
+    orchestratorResults.forEach((result) => {
+      console.log(
+        `   📁 ${result.file}: ${result.matches} matches (${result.pattern})`,
+      )
+    })
+  } else {
+    console.log("❌ ProductOrchestrator NOT found in bundle!")
+  }
+
+  // Check other critical components
+  const criticalComponents = ["App", "public_terms", "GridDefaultPage"]
+
+  criticalComponents.forEach((component) => {
+    console.log(`\n🔍 ${component} Analysis:`)
+    const results = searchForComponent(bundleFiles, component)
+
+    if (results.length > 0) {
+      console.log(`✅ ${component} found:`)
+      results.forEach((result) => {
+        console.log(`   📁 ${result.file}: ${result.matches} matches`)
+      })
+    } else {
+      console.log(`❌ ${component} NOT found in bundle!`)
+    }
+  })
+
+  // Analyze routes
+  console.log("\n🛣️  Route Analysis:")
+  const routeResults = analyzeRoutes(bundleFiles)
+
+  Object.entries(routeResults).forEach(([pattern, results]) => {
+    if (results.length > 0) {
+      console.log(`✅ ${pattern}: Found in ${results.length} files`)
+    } else {
+      console.log(`❌ ${pattern}: Not found`)
+    }
+  })
+
+  // Show all Vue components found
+  console.log("\n📋 All Vue Component References Found:")
+  const allComponents = findAllVueComponents(bundleFiles)
+
+  if (allComponents.length > 0) {
+    allComponents.slice(0, 20).forEach((comp) => console.log(`   - ${comp}`))
+    if (allComponents.length > 20) {
+      console.log(`   ... and ${allComponents.length - 20} more`)
+    }
+  } else {
+    console.log("   ❌ No Vue component references found!")
+  }
+
+  // Bundle size info
+  console.log("\n📏 Bundle Size Info:")
+  let totalSize = 0
+
+  bundleFiles.forEach((file) => {
+    const stats = fs.statSync(file.path)
+    const sizeKB = Math.round(stats.size / 1024)
+
+    totalSize += stats.size
+    console.log(`   📁 ${file.name}: ${sizeKB} KB`)
+  })
+  console.log(`   📊 Total: ${Math.round(totalSize / 1024)} KB`)
+
+  return {
+    orchestratorFound: orchestratorResults.length > 0,
+    bundleFiles: bundleFiles.length,
+    totalComponents: allComponents.length,
+    totalSize: Math.round(totalSize / 1024),
+  }
+}
+
+// Run analysis if script is executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  analyzeBundle()
+}
+
+export default analyzeBundle

package/services/frontend/src/orchestrator/scripts/bundleCheck.js

@@ -0,0 +1,104 @@
+/**
+ * Simple Bundle Check (Plain JavaScript)
+ * Quick check if ProductOrchestrator is in the bundle
+ */
+
+import fs from "fs"
+import path from "path"
+import { fileURLToPath } from "url"
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+console.log("🔍 Simple Bundle Check for ProductOrchestrator\n")
+
+// Check if dist exists
+const distDir = path.join("/app/dist")
+
+if (!fs.existsSync(distDir)) {
+  console.log("❌ No dist directory found. Run `npm run build` first.")
+  process.exit(1)
+}
+
+// Find all JavaScript files in dist
+const findJsFiles = (dir) => {
+  const files = []
+  const items = fs.readdirSync(dir, { withFileTypes: true })
+
+  for (const item of items) {
+    const fullPath = path.join(dir, item.name)
+
+    if (item.isDirectory()) {
+      files.push(...findJsFiles(fullPath))
+    } else if (item.name.endsWith(".js")) {
+      files.push(fullPath)
+    }
+  }
+
+  return files
+}
+
+const jsFiles = findJsFiles(distDir)
+
+console.log(`📦 Found ${jsFiles.length} JavaScript files in dist/`)
+
+let orchestratorFound = false
+let totalSize = 0
+
+jsFiles.forEach((file) => {
+  const stats = fs.statSync(file)
+  const sizeKB = Math.round(stats.size / 1024)
+
+  totalSize += stats.size
+
+  const relativePath = path.relative(distDir, file)
+
+  console.log(`   📁 ${relativePath} (${sizeKB} KB)`)
+
+  // Check file content for ProductOrchestrator
+  const content = fs.readFileSync(file, "utf-8")
+  const patterns = [
+    "ProductOrchestrator",
+    "productorchestrator",
+    "product-orchestrator",
+    "ProductOrchestrator.vue",
+  ]
+
+  const found = patterns.some((pattern) => content.includes(pattern))
+
+  if (found) {
+    orchestratorFound = true
+    console.log(`      ✅ ProductOrchestrator found in this file!`)
+
+    // Show some context
+    const lines = content.split("\n")
+
+    lines.forEach((line, index) => {
+      if (patterns.some((p) => line.includes(p))) {
+        console.log(
+          `         Line ${index + 1}: ${line.trim().substring(0, 100)}...`,
+        )
+      }
+    })
+  }
+})
+
+console.log(`\n📊 Total bundle size: ${Math.round(totalSize / 1024)} KB`)
+console.log(
+  `🎭 ProductOrchestrator in bundle: ${orchestratorFound ? "✅ YES" : "❌ NO"}`,
+)
+
+if (!orchestratorFound) {
+  console.log("\n🚨 ProductOrchestrator NOT found in bundle!")
+  console.log("💡 Possible causes:")
+  console.log("   1. Route import failed")
+  console.log("   2. Component has syntax errors")
+  console.log("   3. Tree-shaking removed it")
+  console.log("   4. Build configuration issue")
+  console.log("\n🔧 Try these steps:")
+  console.log("   1. npm run debug-router")
+  console.log("   2. npm run build -- --debug")
+  console.log("   3. Check your routes.ts file")
+} else {
+  console.log("\n✅ ProductOrchestrator found in bundle - route should work!")
+}

package/services/frontend/src/orchestrator/scripts/debugRouter.js

@@ -0,0 +1,257 @@
+/**
+ * Router Debug Script
+ * Checks if routes are properly configured and components are importable
+ */
+
+import path from "path"
+import { fileURLToPath } from "url"
+import fs from "fs"
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+/**
+ * Check if files exist
+ */
+const checkFileExistence = () => {
+  console.log("📁 Checking file existence...\n")
+
+  const filesToCheck = [
+    {
+      name: "routes.ts",
+      path: path.resolve(__dirname, "../router/routes.ts"),
+    },
+    {
+      name: "router/index.ts",
+      path: path.resolve(__dirname, "../router/index.ts"),
+    },
+    {
+      name: "ProductOrchestrator.vue",
+      path: path.resolve(__dirname, "../ProductOrchestrator.vue"),
+    },
+    { name: "App.vue", path: path.resolve(__dirname, "../App.vue") },
+    { name: "main.ts", path: path.resolve(__dirname, "../main.ts") },
+    { name: "index.ts", path: path.resolve(__dirname, "../index.ts") },
+  ]
+
+  const results = {}
+
+  filesToCheck.forEach((file) => {
+    const exists = fs.existsSync(file.path)
+
+    results[file.name] = { exists, path: file.path }
+    console.log(`   ${exists ? "✅" : "❌"} ${file.name}: ${file.path}`)
+
+    if (exists && file.name.endsWith(".ts")) {
+      // Try to read first few lines for basic syntax check
+      try {
+        const content = fs.readFileSync(file.path, "utf-8")
+        const lines = content.split("\n").slice(0, 5)
+
+        console.log(`      📝 First lines:`)
+        lines.forEach((line, i) => {
+          if (line.trim()) console.log(`         ${i + 1}: ${line.trim()}`)
+        })
+      } catch (error) {
+        console.log(`      ❌ Could not read file: ${error.message}`)
+      }
+    }
+  })
+
+  return results
+}
+
+/**
+ * Analyze routes.ts content
+ */
+const analyzeRoutesContent = () => {
+  console.log("\n📝 Analyzing routes.ts content...")
+
+  const routesPath = path.resolve(__dirname, "../router/routes.ts")
+
+  if (!fs.existsSync(routesPath)) {
+    console.log("❌ routes.ts not found")
+
+    return null
+  }
+
+  try {
+    const content = fs.readFileSync(routesPath, "utf-8")
+
+    // Check for imports
+    const importLines = content
+      .split("\n")
+      .filter((line) => line.trim().startsWith("import"))
+
+    console.log(`   📦 Found ${importLines.length} import statements:`)
+    importLines.forEach((line) => console.log(`      ${line.trim()}`))
+
+    // Check for ProductOrchestrator
+    const hasProductOrchestrator = content.includes("ProductOrchestrator")
+
+    console.log(
+      `   🎭 ProductOrchestrator referenced: ${hasProductOrchestrator ? "✅" : "❌"}`,
+    )
+
+    // Check for export
+    const hasExport = content.includes("export default")
+
+    console.log(`   📤 Has default export: ${hasExport ? "✅" : "❌"}`)
+
+    // Count routes
+    const routeCount = (content.match(/\{[\s\S]*?path:/g) || []).length
+
+    console.log(`   🛣️  Estimated route count: ${routeCount}`)
+
+    return {
+      hasProductOrchestrator,
+      hasExport,
+      routeCount,
+      importCount: importLines.length,
+    }
+  } catch (error) {
+    console.log(`❌ Could not analyze routes.ts: ${error.message}`)
+
+    return null
+  }
+}
+
+/**
+ * Check Vite configuration
+ */
+const checkViteConfig = () => {
+  console.log("\n⚙️  Checking Vite configuration...")
+
+  const viteConfigPath = path.resolve(__dirname, "../vite.config.ts")
+
+  if (!fs.existsSync(viteConfigPath)) {
+    console.log("❌ vite.config.ts not found")
+
+    return
+  }
+
+  try {
+    const content = fs.readFileSync(viteConfigPath, "utf-8")
+
+    // Check for important settings
+    const checks = [
+      { name: "Vue plugin", pattern: /@vitejs\/plugin-vue|vue\(\)/ },
+      { name: "TypeScript support", pattern: /\.ts/ },
+      { name: "Alias configuration", pattern: /alias:|resolve:/ },
+      { name: "Build configuration", pattern: /build:/ },
+      { name: "Router import", pattern: /ProductOrchestrator|router/ },
+    ]
+
+    checks.forEach((check) => {
+      const found = new RegExp(check.pattern).test(content)
+
+      console.log(`   ${found ? "✅" : "❌"} ${check.name}`)
+    })
+  } catch (error) {
+    console.log(`❌ Could not read vite.config.ts: ${error.message}`)
+  }
+}
+
+/**
+ * Check package.json for TypeScript setup
+ */
+const checkTypeScriptSetup = () => {
+  console.log("\n📦 Checking TypeScript setup...")
+
+  const packageJsonPath = path.resolve(__dirname, "../package.json")
+
+  if (!fs.existsSync(packageJsonPath)) {
+    console.log("❌ package.json not found")
+
+    return
+  }
+
+  try {
+    const content = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"))
+
+    // Check for TypeScript dependencies
+    const allDeps = {
+      ...content.dependencies,
+      ...content.devDependencies,
+    }
+
+    const tsChecks = ["typescript", "vue-tsc", "@vitejs/plugin-vue", "vite"]
+
+    tsChecks.forEach((dep) => {
+      const version = allDeps[dep]
+
+      console.log(
+        `   ${version ? "✅" : "❌"} ${dep}: ${version || "not found"}`,
+      )
+    })
+
+    // Check scripts
+    console.log("\n   📜 Build scripts:")
+    const scripts = content.scripts || {}
+
+    Object.entries(scripts).forEach(([name, script]) => {
+      if (name.includes("build") || name.includes("dev")) {
+        console.log(`      ${name}: ${script}`)
+      }
+    })
+  } catch (error) {
+    console.log(`❌ Could not read package.json: ${error.message}`)
+  }
+}
+
+/**
+ * Check main app imports
+ */
+const testMainAppImports = async () => {
+  console.log("\n📱 Testing main app imports...")
+
+  try {
+    // Test main.ts
+    console.log("   Testing main.ts...")
+    const main = await import("../main.ts")
+
+    console.log("   ✅ main.ts imported successfully")
+
+    // Test App.vue
+    console.log("   Testing App.vue...")
+    const app = await import("../App.vue")
+
+    console.log("   ✅ App.vue imported successfully")
+    console.log(`      Default export: ${!!app.default}`)
+
+    // Test index.ts
+    console.log("   Testing index.ts...")
+    const index = await import("../index.ts")
+
+    console.log("   ✅ index.ts imported successfully")
+  } catch (error) {
+    console.error("❌ Main app import failed:", error.message)
+  }
+}
+
+/**
+ * Main debug function
+ */
+const debugRouter = async () => {
+  console.log("🐛 Router Debug Analysis")
+  console.log("========================\n")
+
+  await testRouteImports()
+  await testRouterCreation()
+  await testMainAppImports()
+
+  console.log("\n💡 Debugging Tips:")
+  console.log(
+    "   1. If ProductOrchestrator import fails: Check file path and existence",
+  )
+  console.log("   2. If routes are empty: Check routes.ts export")
+  console.log("   3. If router creation fails: Check router/index.ts")
+  console.log("   4. Run `npm run build --debug` to see Vite's perspective")
+}
+
+// Run debug if script is executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  debugRouter()
+}
+
+export default debugRouter

package/services/frontend/src/orchestrator/setup/application.ts

@@ -0,0 +1,3 @@
+export const initApp = async (corePluginApi) => {
+  console.log("initApp was called")
+}