.option('--rpc', 'use Hono RPC client for type-safe API communication')

    if (options.rpc) {

      await patchFilesForRPC(projectPath);

    }

    if (!options.yes && !options.rpc) {

      const { useRpc } = await prompts({

        type: 'confirm',

        name: 'useRpc',

        message: 'Use Hono RPC client for type-safe API communication?',

        initial: false

      });

      if (useRpc) {

        await patchFilesForRPC(projectPath);

      }

    }

async function patchFilesForRPC(projectPath) {

  const spinner = ora('Setting up RPC client...').start();

  try {

    // 1. Update client package.json to ensure hono client is installed

    const clientPkgPath = path.join(projectPath, 'client', 'package.json');

    const clientPkg = await fs.readJson(clientPkgPath);

    // Make sure hono client is in dependencies

    if (!clientPkg.dependencies.hono) {

      clientPkg.dependencies.hono = "^4.7.7";

    }

    await fs.writeJson(clientPkgPath, clientPkg, { spaces: 2 });

    // 2. Server modification - targeted approach based on known structure

    const serverIndexPath = path.join(projectPath, 'server', 'src', 'index.ts');

    let serverContent = await fs.readFile(serverIndexPath, 'utf8');

    // If the server doesn't already have the RPC structure, update it

    if (!serverContent.includes('export type AppType')) {

      // Create the target server content based on the template

      const updatedServerContent = `import { Hono } from 'hono'

import { cors } from 'hono/cors'

import type { ApiResponse } from 'shared/dist'

const app = new Hono()

app.use(cors())

const routes = app.get('/', (c) => {

  return c.text('Hello Hono!')

})

.get('/hello', async (c) => {

  const data: ApiResponse = {

    message: "Hello BHVR!",

    success: true

  }

  return c.json(data, { status: 200 })

})

export type AppType = typeof routes

export default app`;

      await fs.writeFile(serverIndexPath, updatedServerContent, 'utf8');

    }

    // 3. Update App.tsx with RPC implementation

    const appTsxPath = path.join(projectPath, 'client', 'src', 'App.tsx');

    let appTsxContent = await fs.readFile(appTsxPath, 'utf8');

    // Only make changes if RPC isn't already set up

    if (!appTsxContent.includes('import { hc } from \'hono/client\'')) {

      // Find the key parts of the file we need to preserve

      const importReactMatch = appTsxContent.match(/import\s+{\s*useState\s*}.*?from\s+['"]react['"]/);

      const importBeaverMatch = appTsxContent.match(/import\s+beaver\s+from\s+['"]\.\/assets\/beaver\.svg['"]/);

      const importSharedMatch = appTsxContent.match(/import.*?from\s+['"]shared['"]/);

      const importCssMatch = appTsxContent.match(/import\s+['"]\.\/App\.css['"]/);

      // Make sure we found the required parts

      if (importReactMatch && importBeaverMatch && importCssMatch) {

        // Get the current return JSX part

        const returnJsxMatch = appTsxContent.match(/return\s*\(\s*<>([\s\S]*?)<\/>/);

        if (returnJsxMatch) {

          // Create the updated App.tsx content

          const updatedAppContent = `import { useState } from 'react'

import beaver from './assets/beaver.svg'

import type { AppType } from '../../server/src'

import { hc } from 'hono/client'

${importSharedMatch ? importSharedMatch[0] : 'import { ApiResponse } from \'shared\''}

import './App.css'

const SERVER_URL = import.meta.env.VITE_SERVER_URL || "http://localhost:3000"

const client = hc<AppType>(SERVER_URL);

type ResponseType = Awaited<ReturnType<typeof client.hello.$get>>;

function App() {

  const [data, setData] = useState<Awaited<ReturnType<ResponseType["json"]>> | undefined>()

  async function sendRequest() {

    try {

      const res = await client.hello.$get()

      if(!res.ok){

        console.log("Error fetching data")

        return

      }

      const data = await res.json()

      setData(data)

    } catch (error) {

      console.log(error)

    }

  }

  ${returnJsxMatch[0]}

  )

}

export default App`;

          await fs.writeFile(appTsxPath, updatedAppContent, 'utf8');

        }

      }

    }

    spinner.succeed('RPC client setup completed');

    return true;

  } catch (err) {

    spinner.fail('Failed to set up RPC client');

    console.error(chalk.red('Error:'), err.message);

    return false;

  }

}