#!/bin/bash
# Check for any direct user table references in the codebase that might need updating
rg -l "user.*isOnboarding|isOnboarding.*user" --type ts --type tsx

# Check for any TypeScript interfaces or types that need to be updated
ast-grep --pattern 'interface User {
  $$$
}'

#!/bin/bash
# Check for any direct user table references in the codebase that might need updating
rg -l "user.*isOnboarding|isOnboarding.*user" --type typescript

# Look for User interface/type definitions
rg -A 5 "interface User|type User" --type typescript

# Check Prisma schema for user model definition
fd "schema.prisma" --exec cat {}

#!/bin/bash
# Try with different file extensions for TypeScript files
rg -l "user.*isOnboarding|isOnboarding.*user" -g "*.ts"

# Search for any files that might be using the User model or isOnboarding field
rg -A 3 "isOnboarding" -g "*.ts"

# Look for User type definitions with different extension pattern
rg -A 5 "interface User|type User" -g "*.ts"

#!/bin/bash
# Search for UIState type definition
ast-grep --pattern 'type UIState = {
  $$$
}'

#!/bin/bash
# Let's try a different approach to find UIState definition
# First, let's find all files that mention UIState
rg "UIState" -l

# Then let's get more context around UIState mentions
rg "UIState" -B 2 -A 5

#!/bin/bash
# Let's find the ClientMessage type definition since UIState is defined as ClientMessage[]
rg "type ClientMessage" -B 2 -A 5

# Also search for any interface definition of ClientMessage
rg "interface ClientMessage" -B 2 -A 5

#!/bin/bash
# Search for routes that might be affected by the layout change
fd --type f "page.tsx" "apps/app/app/(routes)"

#!/bin/bash
# Check the content of route pages to verify their layout dependencies
echo "=== Content of [slug]/page.tsx ==="
cat "apps/app/app/(routes)/[slug]/page.tsx"
echo -e "\n=== Content of settings/page.tsx ==="
cat "apps/app/app/(routes)/settings/page.tsx"

# Check if there are any layout files in the routes
echo -e "\n=== Layout files in routes ==="
fd --type f "layout.tsx" "apps/app/app/(routes)"

#!/bin/bash
# Check the content of the route layout to verify it handles the sidebar and other layout components
cat "apps/app/app/(routes)/layout.tsx"

#!/bin/bash
# Check if there are any other system prompts in the codebase for consistency
rg -g '!*.{json,lock}' "system.*:.*\".*\"" 

#!/bin/bash
# Check for public routes that might need to be excluded
rg -l "export const dynamic = 'force-static'" 

#!/bin/bash
# Let's check for public routes and authentication patterns in a different way
# First, let's look for route files
fd "page.tsx" "app"

# Then, let's look for authentication checks in middleware
rg -A 5 "auth" middleware.ts

# Also check for any route protection patterns
rg -l "useAuth|getSession|withAuth|isAuthenticated|requireAuth"

#!/bin/bash
# Let's correct the path and check the middleware content
cat apps/app/middleware.ts

# Let's also check the structure of protected routes
fd . apps/www/app/(auth)
fd . apps/app

# Check authentication implementation
rg -A 5 "useAuth|getSession|withAuth|isAuthenticated|requireAuth" apps/www/lib/server.ts apps/www/app/(auth)/dashboard/page.tsx

#!/bin/bash
# Check if there are any foreign key constraints or indexes referencing this field
rg -A 5 "isOnboarding" "packages/database/prisma/migrations"

# Check for any direct field usage in the codebase
rg "isOnboarding" --type typescript

#!/bin/bash
# Check for any direct field usage in the codebase with ripgrep
rg "isOnboarding"

# Check migration files to understand the full context
fd "migration.sql" packages/database/prisma/migrations --exec cat {}

#!/bin/bash
# Check ai package's peer dependencies and React compatibility
echo "Checking ai package details:"
curl -s https://registry.npmjs.org/ai | jq '.["dist-tags"].latest, .versions[.["dist-tags"].latest].peerDependencies'

# Look for React-related issues
gh api graphql -f query='
{
  repository(owner: "vercel", name: "ai") {
    issues(last: 5, states: OPEN, labels: ["react"]) {
      nodes {
        title
        createdAt
      }
    }
  }
}'

#!/bin/bash
# Search for any remaining references to port 5555 in the codebase
rg -g '!package.json' '5555'

# Search for environment files that might need updating
fd -g '.env*'

#!/bin/bash
# Search for any remaining references to port 5555 in the codebase, including hidden files
rg -g '!package.json' --hidden '5555'

# Search for environment files and docker files that might contain port configurations
fd -H -e env -e env.example -e env.local -e env.development -e env.production -e dockerfile -e yml -e yaml

# Search for port 3001 references to understand the integration points
rg -g '!package.json' '3001'

#!/bin/bash
# Description: Verify the implementation of imported types and function
# Look for ClientMessage and ServerMessage type definitions
ast-grep --pattern 'type (ClientMessage|ServerMessage) = {
  $$$
}'

# Look for sendMessage function implementation
ast-grep --pattern 'const sendMessage = async ($$$) => {
  $$$
}'

#!/bin/bash
# Let's try a different approach to find the type definitions and function
# First, let's locate the action file
fd "action.ts" --type f

# Then, let's examine its contents
rg -A 5 "type (ClientMessage|ServerMessage)" --type ts
rg -A 5 "sendMessage" --type ts

#!/bin/bash
# Description: Verify integration with onboarding components and user flow

# Look for onboarding-related components
fd -e tsx -e ts --exec grep -l "onboarding" {}

# Check for user session management integration
ast-grep --pattern 'useSession|getSession|withAuth'

# Look for database schema changes related to onboarding
fd "schema.prisma" --exec grep -A 5 -B 5 "onboarding" {}

#!/bin/bash
# Let's examine the onboarding-related files more closely

# Check the middleware implementation
cat apps/app/middleware.ts

# Examine the onboarding page
cat "apps/app/app/(onboarding)/onboarding/page.tsx"

# Look at the actions implementation
cat apps/app/actions/action.tsx

# Search for AI component usage
rg -l "AI" apps/app/app/

#!/bin/bash
# Let's check the remaining components

# Check the chatbox component
cat "@/components/custom/onboarding/chatbox"

# Check the onboarding layout
cat "apps/app/app/(onboarding)/onboarding/layout.tsx"

# Look for BotMessage component
cat "@/components/custom/onboarding/message"

# Check for any database schema
fd "schema.prisma"

#!/bin/bash
# Let's check the components with correct paths and schema

# Check for chatbox component with correct path structure
fd -e tsx -e ts "chatbox" apps/app/components

# Look for message component
fd -e tsx -e ts "message" apps/app/components

# Examine the database schema
cat packages/database/prisma/schema.prisma

#!/bin/bash
# Final check of the chatbox and message components

# Examine the chatbox implementation
cat apps/app/components/custom/onboarding/chatbox.tsx

# Check the message component
cat apps/app/components/custom/onboarding/message.tsx