# في مشروعك الحالي
1. افتح ChatPanel واكتب:
   "Give me a comprehensive overview of this project.
   What tech stack? What patterns? What debts?"

2. حدد ملفًا معقدًا واضغط Cmd+K:
   "Refactor this to be more maintainable.
   Extract complex logic into separate functions.
   Add TypeScript types."

3. راجع التغييرات وافهمها
4. اضغط Tab لقبول التغييرات

# في Windsurf
1. فعّل Cascade
2. حدد 3 ملفات متعلقة بـ feature واحد
3. اطلب:
   "Find potential bugs in these files.
   Look for:
   - Missing error handling
   - Race conditions
   - Memory leaks"

4. افهم كل إصلاح مقترح
5. طبق التغييرات

// settings.json
{
  "github.copilot.enable": {
    "*": true,
    "yaml": false,
    "plaintext": false
  },
  "editor.inlineSuggest.enabled": true,
  "editor.suggestSelection": "first",
  "editor.quickSuggestions": {
    "other": true,
    "comments": false,
    "strings": true
  },
  "continue.telemetryEnabled": false
}

# أعد VS Code مع إضافات AI
1. ثبت Copilot + Continue.dev
2. أنشئ keybindings.json:
   [
     {
       "key": "cmd+shift+c",
       "command": "continue.continuePrompt"
     },
     {
       "key": "cmd+shift+g",
       "command": "github.copilot.focus"
     }
   ]

3. جرّب على مشروع:
   - استخدم Copilot لل suggestions
   - استخدم Continue للـ explanations
   - قارن النتائج

# .claude-rules
project:
  name: "My SaaS App"
  type: "Next.js 14 + TypeScript + Supabase"

coding_style:
  - "Use functional components"
  - "Prefer server components"
  - "Use TypeScript strict mode"
  - "Follow React best practices"
  - "Use Tailwind for styling"
  - "Write tests for all utilities"

ai_preferences:
  default_model: "claude-3-5-sonnet-20241022"
  temperature: 0.2
  max_tokens: 4000

agents:
  planner: "claude-3-opus"
  coder: "claude-3-5-sonnet"
  reviewer: "claude-3-sonnet"

custom_prompts:
  refactor: |
    Refactor this code to:
    1. Improve readability
    2. Reduce complexity
    3. Add error handling
    4. Maintain same functionality

  test: |
    Generate comprehensive tests including:
    1. Happy path
    2. Edge cases
    3. Error conditions
    4. Boundary testing

# على مشروع حقيقي
1. أنشئ .claude-rules مفصّل
2. جرّب:
   claude scan .
   claude ask "Review the codebase for security issues"
   claude generate "Create an admin dashboard" --with-tests

3. قارن النتائج مع/بدون .claude-rules

┌─────────────────────────────────────┐
│         User Request               │
└────────────┬────────────────────────┘
             │
             ▼
┌─────────────────────────────────────┐
│      Orchestrator Agent             │
│  (Coordinates all agents)           │
└────────────┬────────────────────────┘
             │
     ┌───────┴────────┐
     │                │
     ▼                ▼
┌─────────┐      ┌──────────┐
│ Planner │      │  Coder   │
│ Agent   │      │  Agent   │
└────┬────┘      └─────┬────┘
     │                 │
     ▼                 ▼
┌─────────┐      ┌──────────┐
│Reviewer │◄─────│ Tester   │
│ Agent   │      │  Agent   │
└────┬────┘      └─────┬────┘
     │                 │
     ▼                 │
┌─────────┐            │
│Debugger │◄───────────┘
│ Agent   │
└────┬────┘
     │
     ▼
┌─────────────────────────────────────┐
│      Final Output                   │
└─────────────────────────────────────┘

# .opencode-rules
project:
  name: "Enterprise App"
  stack:
    - "Next.js 14"
    - "TypeScript 5"
    - "Prisma ORM"
    - "PostgreSQL"
    - "Redis for caching"

code_quality:
  - "100% test coverage for utilities"
  - "TypeScript strict mode"
  - "No any types"
  - "ESLint + Prettier"
  - "Husky pre-commit hooks"

agents:
  planner:
    model: "claude-3-opus"
    temperature: 0.3

  coder:
    model: "claude-3-5-sonnet"
    temperature: 0.2
    max_iterations: 3

  reviewer:
    model: "claude-3-sonnet"
    strictness: "high"
    check:
      - security
      - performance
      - best_practices

  tester:
    model: "claude-3-5-sonnet"
    framework: "vitest"
    coverage_target: 80

  debugger:
    model: "claude-3-opus"
    approach: "systematic"

# بناء feature كامل باستخدام agents
opencode agent "
Build a payment processing system with:
1. Stripe integration
2. Webhook handling
3. Payment history
4. Invoice generation

Include:
- Complete error handling
- Comprehensive tests
- Type definitions
- Documentation
"

# راقب كيف يعمل agents معًا
# افهم كل قرار
# راجع الكود النهائي

# استعلام مع معاملات متقدمة
gh copilot suggest "find all files larger than 10MB" \
  --shell bash \
  --explain

# شرح مفصّل
gh copilot explain "docker-compose up -d --build --force-recreate" \
  --detailed

# اقتراحات متعددة
gh copilot suggest "deploy to production" \
  --suggestions 3

# مقارنة الأدوات
# نفّذ نفس المهمة بكل أداة

echo "Building a REST API"

# مع Claude CLI
claude generate "Create a REST API for products" \
  --output claude-version/

# مع OpenCode
opencode build "Create a REST API for products" \
  --output opencode-version/

# مع Aider
aider "Create a REST API for products"

# قارن:
# - جودة الكود
# - السرعة
# - سهولة الاستخدام

// src/lib/openai.ts
import OpenAI from 'openai';

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

export async function generateCode(
  prompt: string,
  language: string = 'typescript'
): Promise<string> {
  const response = await openai.chat.completions.create({
    model: 'gpt-4-turbo',
    messages: [
      {
        role: 'system',
        content: `You are an expert ${language} developer.
        Generate clean, well-documented code.`
      },
      {
        role: 'user',
        content: prompt
      }
    ],
    temperature: 0.2,
    max_tokens: 2000,
  });

  return response.choices[0].message.content || '';
}

// Usage
const code = await generateCode(
  'Create a React hook for fetching data with loading and error states'
);

// تمريرة كود كاملة
export async function refactorCode(
  code: string,
  instructions: string
): Promise<{
  refactored: string;
  explanation: string;
  changes: string[];
}> {
  const response = await openai.chat.completions.create({
    model: 'gpt-4-turbo',
    messages: [
      {
        role: 'system',
        content: `You are a code refactoring expert.
        Respond in JSON format:
        {
          "refactored": "the refactored code",
          "explanation": "what changed and why",
          "changes": ["list of changes"]
        }`
      },
      {
        role: 'user',
        content: `Refactor this code:

Instructions: ${instructions}`
      }
    ],
    response_format: { type: "json_object" },
  });

  return JSON.parse(response.choices[0].message.content || '{}');
}

// tools/ai-assistant/src/index.ts
import OpenAI from 'openai';

interface AIAssistantConfig {
  model: 'gpt-4' | 'claude-3-opus';
  systemPrompt: string;
  temperature?: number;
}

class AIAssistant {
  private client: OpenAI;
  private config: AIAssistantConfig;

  constructor(config: AIAssistantConfig) {
    this.config = config;
    this.client = new OpenAI({
      apiKey: process.env.OPENAI_API_KEY,
    });
  }

  async chat(message: string, context?: string): Promise<string> {
    const messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[] = [
      {
        role: 'system',
        content: this.config.systemPrompt,
      }
    ];

    if (context) {
      messages.push({
        role: 'user',
        content: `Context:\n${context}`,
      });
    }

    messages.push({
      role: 'user',
      content: message,
    });

    const response = await this.client.chat.completions.create({
      model: 'gpt-4-turbo',
      messages,
      temperature: this.config.temperature || 0.7,
    });

    return response.choices[0].message.content || '';
  }

  async generateCode(
    description: string,
    language: string
  ): Promise<string> {
    return this.chat(
      `Generate ${language} code for: ${description}`,
      undefined
    );
  }

  async reviewCode(code: string): Promise<{
    issues: string[];
    suggestions: string[];
    rating: number;
  }> {
    const response = await this.chat(
      `Review this code:\n```\n${code}\n```
      Respond in JSON format with issues, suggestions, and rating (1-10).`,
      undefined
    );

    return JSON.parse(response);
  }
}

// Usage
const assistant = new AIAssistant({
  model: 'gpt-4',
  systemPrompt: 'You are an expert TypeScript developer.',
  temperature: 0.2,
});

// Generate code
const code = await assistant.generateCode(
  'Create a debounce function',
  'typescript'
);

// Review code
const review = await assistant.reviewCode(`
  function debounce(fn, delay) {
    let timeout;
    return function(...args) {
      clearTimeout(timeout);
      timeout = setTimeout(() => fn.apply(this, args), delay);
    };
  }
`);