@hd-agent-kit/cli 1.0.0

package/README.md

@@ -0,0 +1,83 @@
+# @hd-agent-kit
+
+AI agent configuration kit for Claude Code, Cursor, Windsurf, and OpenCode.
+
+Sets up `AGENTS.md` and `.agents/skills/` in your project so AI assistants follow consistent rules and have access to slash commands like `/commit`, `/analyze`, `/refactor`, etc.
+
+## Installation
+
+```bash
+npx @hd-agent-kit/cli init
+```
+
+This will:
+1. Copy `AGENTS.md` and `.agents/skills/` to your project root
+2. Configure global gitignore so these files don't get pushed to your repo
+
+## Commands
+
+### `init`
+Copy agent files to your project and setup global gitignore.
+
+```bash
+npx @hd-agent-kit/cli init          # prompts before overwriting
+npx @hd-agent-kit/cli init --force  # overwrites without asking
+```
+
+### `update`
+Update all agent files to the latest version (overwrites existing files).
+
+```bash
+npx @hd-agent-kit/cli update
+```
+
+### `gitignore`
+Only setup the global gitignore (without copying files).
+
+```bash
+npx @hd-agent-kit/cli gitignore
+```
+
+## What Gets Installed
+
+```
+your-project/
+├── AGENTS.md                              ← Global AI rules
+└── .agents/
+    └── skills/
+        ├── analyze/SKILL.md               ← /analyze — project analysis
+        ├── commit/SKILL.md                ← /commit — smart commits
+        ├── document/SKILL.md              ← /document — documentation
+        ├── performance-check/SKILL.md     ← /performance-check
+        ├── refactor/SKILL.md              ← /refactor — safe refactoring
+        ├── security-scan/SKILL.md         ← /security-scan
+        └── write-tests/SKILL.md           ← /write-tests — test generation
+```
+
+## Global Gitignore
+
+The `init` and `gitignore` commands add these entries to your global gitignore:
+
+```
+AGENTS.md
+.agents/
+project-rules.md
+```
+
+This prevents agent config files from being committed to any project.
+
+## Available Slash Commands
+
+| Command | Description |
+|---------|-------------|
+| `/analyze` | Analyze project and generate `project-rules.md` |
+| `/commit` | Analyze changes and propose a commit message |
+| `/refactor [file]` | Create a step-by-step refactor plan |
+| `/write-tests [file]` | Generate test files |
+| `/document [file]` | Generate JSDoc/TSDoc or README |
+| `/performance-check` | Bundle, render, and Core Web Vitals analysis |
+| `/security-scan` | Dependency audit, XSS/CSRF risk detection |
+
+## License
+
+MIT

package/bin/cli.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+
+const { init, update, setupGlobalGitignore } = require('../src/index');
+
+const args = process.argv.slice(2);
+const command = args[0];
+const flags = args.slice(1);
+const force = flags.includes('--force') || flags.includes('-f');
+
+const HELP_TEXT = `
+  @hd-agent-kit — AI Agent Configuration Kit
+
+  Usage:
+    npx @hd-agent-kit/cli <command> [options]
+
+  Commands:
+    init        Copy agent files to project + setup global gitignore
+    update      Update existing agent files (overwrites all)
+    gitignore   Only setup global gitignore
+
+  Options:
+    --force, -f   Overwrite existing files without prompting
+    --help, -h    Show this help message
+`;
+
+async function main() {
+  if (!command || command === '--help' || command === '-h') {
+    console.log(HELP_TEXT);
+    process.exit(0);
+  }
+
+  switch (command) {
+    case 'init':
+      await init({ force });
+      break;
+    case 'update':
+      await update();
+      break;
+    case 'gitignore':
+      await setupGlobalGitignore();
+      break;
+    default:
+      console.error(`  Unknown command: ${command}\n`);
+      console.log(HELP_TEXT);
+      process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error('\n  Error:', err.message);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@hd-agent-kit/cli",
+  "version": "1.0.0",
+  "description": "AI agent configuration kit — sets up AGENTS.md and skill files for Claude Code, Cursor, Windsurf, and OpenCode",
+  "bin": {
+    "hd-agent-kit": "./bin/cli.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "templates/"
+  ],
+  "keywords": [
+    "ai",
+    "agents",
+    "claude",
+    "cursor",
+    "windsurf",
+    "opencode",
+    "developer-tools",
+    "cli"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}

package/src/index.js

@@ -0,0 +1,151 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const readline = require('readline');
+
+const TEMPLATES_DIR = path.join(__dirname, '..', 'templates');
+const GITIGNORE_ENTRIES = ['AGENTS.md', '.agents/', 'project-rules.md'];
+
+// ── Helpers ──────────────────────────────────────────────
+
+function log(msg) {
+  console.log(`  ${msg}`);
+}
+
+function success(msg) {
+  console.log(`  \u2713 ${msg}`);
+}
+
+function warn(msg) {
+  console.log(`  ! ${msg}`);
+}
+
+function ask(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(`  ${question} (y/N) `, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase() === 'y');
+    });
+  });
+}
+
+function getAllFiles(dir, base = dir) {
+  const results = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...getAllFiles(fullPath, base));
+    } else {
+      results.push(path.relative(base, fullPath));
+    }
+  }
+  return results;
+}
+
+// ── Global Gitignore ─────────────────────────────────────
+
+async function setupGlobalGitignore() {
+  console.log('\n  \uD83D\uDD12 Setting up global gitignore...\n');
+
+  let gitignorePath;
+
+  try {
+    gitignorePath = execSync('git config --global core.excludesFile', { encoding: 'utf-8' }).trim();
+  } catch {
+    // No global gitignore configured yet
+    gitignorePath = '';
+  }
+
+  // Resolve ~ to home directory
+  if (gitignorePath.startsWith('~')) {
+    gitignorePath = path.join(process.env.HOME || process.env.USERPROFILE, gitignorePath.slice(1));
+  }
+
+  if (!gitignorePath) {
+    const homedir = process.env.HOME || process.env.USERPROFILE;
+    gitignorePath = path.join(homedir, '.gitignore_global');
+
+    execSync(`git config --global core.excludesFile "${gitignorePath}"`);
+    log(`Global gitignore created: ${gitignorePath}`);
+  }
+
+  // Read existing content or start fresh
+  let content = '';
+  if (fs.existsSync(gitignorePath)) {
+    content = fs.readFileSync(gitignorePath, 'utf-8');
+  }
+
+  const lines = content.split('\n').map((l) => l.trim());
+  let added = false;
+
+  for (const entry of GITIGNORE_ENTRIES) {
+    if (!lines.includes(entry)) {
+      content = content.trimEnd() + '\n' + entry;
+      success(`${entry} added`);
+      added = true;
+    } else {
+      log(`${entry} already exists, skipped`);
+    }
+  }
+
+  if (added) {
+    fs.writeFileSync(gitignorePath, content.trimEnd() + '\n', 'utf-8');
+  }
+
+  console.log('');
+}
+
+// ── Copy Files ───────────────────────────────────────────
+
+async function copyFiles(targetDir, { force = false } = {}) {
+  console.log('\n  \uD83D\uDCC1 Copying agent files...\n');
+
+  const files = getAllFiles(TEMPLATES_DIR);
+
+  for (const relPath of files) {
+    const src = path.join(TEMPLATES_DIR, relPath);
+    const dest = path.join(targetDir, relPath);
+    const destDir = path.dirname(dest);
+
+    // Check if file exists
+    if (!force && fs.existsSync(dest)) {
+      const overwrite = await ask(`${relPath} already exists. Overwrite?`);
+      if (!overwrite) {
+        warn(`${relPath} skipped`);
+        continue;
+      }
+    }
+
+    fs.mkdirSync(destDir, { recursive: true });
+    fs.copyFileSync(src, dest);
+    success(relPath);
+  }
+
+  console.log('');
+}
+
+// ── Commands ─────────────────────────────────────────────
+
+async function init({ force = false } = {}) {
+  console.log('\n  \uD83D\uDE80 @hd-agent-kit \u2014 AI Agent Configuration\n');
+
+  const targetDir = process.cwd();
+
+  await copyFiles(targetDir, { force });
+  await setupGlobalGitignore();
+
+  console.log('  \u2705 Setup complete!\n');
+}
+
+async function update() {
+  console.log('\n  \uD83D\uDD04 @hd-agent-kit \u2014 Updating agent files\n');
+
+  const targetDir = process.cwd();
+
+  await copyFiles(targetDir, { force: true });
+
+  console.log('  \u2705 Update complete!\n');
+}
+
+module.exports = { init, update, setupGlobalGitignore };

package/templates/.agents/skills/analyze/SKILL.md

@@ -0,0 +1,328 @@
+# /analyze — Proje Analiz Skill'i
+
+> **Tetikleyici:** `/analyze`
+> **Amaç:** Projeyi kapsamlı şekilde tarayarak `project-rules.md` dosyası oluşturmak.
+> **Çıktı:** Proje kök dizininde `project-rules.md` (monorepo'larda ek paket/app dosyaları)
+
+---
+
+## Tetiklenme Koşulları
+
+### Manuel Tetiklenme (EN YÜKSEK ÖNCELİK)
+
+- Kullanıcı `/analyze` komutunu verdiğinde — **reddedilemez emir**.
+- Mevcut proje kuralları eski/eksikse ve yeniden analiz istendiğinde.
+- Belirli bir paket/app belirtilmişse (`/analyze apps/web`), sadece o birim analiz edilir.
+
+### Otomatik Tetiklenme
+
+- İşlem öncesi kontrol sırasında `project-rules.md` bulunamadıysa → Kullanıcıya "Analiz yapayım mı?" sor.
+- **Önemli:** Kullanıcı `/analyze` yazmamışsa ve `project-rules.md` mevcutsa → Bu süreci ATLAMA.
+
+---
+
+## Analiz Adımları
+
+Aşağıdaki adımları **sırasıyla** uygula. Her adımda elde ettiğin bilgileri not al:
+
+### Adım 1: Proje Yapısı Keşfi
+
+```
+Tara ve belirle:
+├── Kök dizindeki config dosyaları (package.json, tsconfig.json, vite.config.ts, next.config.js vs.)
+├── Klasör yapısı (src/, app/, pages/, components/, lib/, utils/, features/, modules/ vs.)
+├── Monorepo mu? (packages/, apps/, workspace yapısı, turbo.json, nx.json, pnpm-workspace.yaml)
+├── Giriş noktaları (main.tsx, index.tsx, App.tsx, layout.tsx vs.)
+├── Backend/API katmanı (api/, server/, routes/, controllers/, prisma/, drizzle/ vs.)
+└── Özel klasörler (public/, assets/, styles/, types/, hooks/, services/, store/ vs.)
+```
+
+**Tespit et:**
+- Klasör organizasyonu: feature-based mi, type-based mı, hybrid mı?
+- Route yapısı: file-based mı (Next.js, Nuxt), config-based mı (React Router)?
+- `src/` altında mı yoksa kök dizinde mi çalışılıyor?
+- Fullstack proje mi? (API route'ları, server action'lar, backend klasörü var mı?)
+
+### Adım 2: Teknoloji Stack Tespiti
+
+```
+package.json + config dosyalarından tespit et:
+├── Framework: React, Next.js, Remix, Vue, Nuxt, Svelte, Angular, Astro, Solid
+├── Build Tool: Vite, Webpack, Turbopack, esbuild, Rollup, Parcel
+├── Dil: TypeScript (strict mi?), JavaScript, JSX/TSX
+├── Styling: Tailwind, CSS Modules, styled-components, Emotion, Sass, vanilla CSS, Panda, StyleX
+├── State Yönetimi: Zustand, Redux Toolkit, Jotai, Recoil, Pinia, MobX, XState, Context API
+├── Server State: TanStack Query, SWR, Apollo Client, tRPC, RTK Query
+├── Form: React Hook Form, Formik, Zod, Yup, Valibot
+├── Test: Vitest, Jest, Testing Library, Playwright, Cypress, MSW
+├── Linting: ESLint, Biome, Prettier, Stylelint
+├── UI Kit: shadcn/ui, Radix, Headless UI, MUI, Ant Design, Mantine, Chakra
+├── Animasyon: Framer Motion, GSAP, Motion One, CSS transitions
+├── i18n: next-intl, react-i18next, vue-i18n, @formatjs, Paraglide
+├── Backend/API: Express, Fastify, Hono, tRPC, GraphQL, REST
+├── ORM/DB: Prisma, Drizzle, TypeORM, Mongoose, Supabase client
+├── Auth: NextAuth/Auth.js, Clerk, Supabase Auth, Firebase Auth, Lucia
+└── Diğer: Monorepo tooling, deployment config, analytics
+```
+
+### Adım 3: Kod Stili & Pattern Analizi
+
+Mevcut kaynak kodunu **en az 10-15 dosya** üzerinden örnekleyerek analiz et:
+
+**Component Yapısı:**
+- Arrow function mı, function declaration mı?
+- Props inline mı tanımlanmış, ayrı interface/type mı?
+- Export: default export mı, named export mı?
+- Dosya başına tek component mı, birden fazla mı?
+- Component dosya uzantısı: `.tsx`, `.jsx`, `.vue`, `.svelte`?
+
+**Hook Kullanımı:**
+- Custom hook'lar var mı? Nerede bulunuyor?
+- Hangi hook pattern'ları tercih ediliyor?
+- Data fetching nasıl yapılıyor?
+
+**Stil Yaklaşımı:**
+- Tailwind kullanılıyorsa: `cn()` / `clsx()` / `cva()` var mı? Hangi utility pattern'lar yaygın?
+- CSS Modules ise: Adlandırma convention'ı ne?
+- Theme/token sistemi var mı?
+
+**Import Sıralaması:**
+- Mevcut koddaki import sıralamasını tespit et (React, 3rd party, internal, styles, types vs.)
+- Absolute import path alias var mı? (`@/`, `~/`, `#/`)
+
+**Tip Tanımları:**
+- Type'lar nerede tanımlanıyor? (Component yanında, ayrı `types/` klasöründe, global `types.d.ts`?)
+- `interface` mi `type` mı daha yaygın?
+- Zod/Valibot schema'dan tip türetme var mı?
+
+**Hata Yönetimi:**
+- Error boundary kullanılıyor mu?
+- API hataları nasıl handle ediliyor?
+- Toast/notification sistemi var mı?
+
+**Backend/API Katmanı (varsa):**
+- API route yapısı nasıl? (Next.js App Router, Pages Router, Express router vs.)
+- Validation nerede yapılıyor? (Middleware, handler içinde, Zod schema)
+- Auth middleware var mı? Nasıl uygulanıyor?
+- DB query'leri nerede yazılıyor? (Service layer, doğrudan handler'da)
+
+### Adım 4: Konfigürasyon Analizi
+
+```
+Detaylı incele:
+├── tsconfig.json → strict, paths, target, module, jsx ayarları
+├── ESLint config → Aktif kurallar, custom rules, extends
+├── Prettier config → Print width, tab/space, trailing comma, quotes
+├── Tailwind config → Custom theme, plugins, content paths
+├── Vite/Webpack config → Alias'lar, plugins, env handling
+├── .env.example → Env değişken yapısı ve adlandırma
+├── CI/CD config → Lint, test, build pipeline'ları
+├── Docker config → Dockerfile, docker-compose.yml varsa
+└── Deployment config → vercel.json, netlify.toml, fly.toml vs.
+```
+
+### Adım 5: Test Stratejisi Tespiti
+
+- Hangi test runner kullanılıyor?
+- Test dosyaları nerede? (`__tests__/`, `*.test.ts`, `*.spec.ts`, yanında mı ayrı klasörde mi?)
+- Test coverage hedefi var mı?
+- E2E test altyapısı var mı?
+- MSW veya benzeri API mock'lama var mı?
+- Test utility/helper dosyaları var mı?
+
+### Adım 6: Git & Workflow Analizi
+
+- Commit geçmişinden mesaj formatını tespit et (Conventional Commits mi, serbest mi?)
+- Branch stratejisi (gitflow, trunk-based, GitHub flow?)
+- PR template var mı?
+- Husky/lint-staged gibi git hook'lar kurulu mu?
+- Changelog yönetimi var mı?
+
+### Adım 7: Environment & Deployment Analizi
+
+- Hangi ortamlar tanımlı? (development, staging, production)
+- `.env.example` veya `.env.local.example` var mı?
+- Env variable adlandırma convention'ı ne? (`NEXT_PUBLIC_`, `VITE_`, `REACT_APP_` vs.)
+- Deployment target ne? (Vercel, Netlify, AWS, Docker, self-hosted)
+- CI/CD pipeline'ı kurulu mu? (GitHub Actions, GitLab CI, CircleCI)
+- Build komutu ve output dizini ne?
+
+### Adım 8: i18n & Lokalizasyon Analizi
+
+- i18n kütüphanesi kullanılıyor mu?
+- Çeviri dosyaları nerede? (`locales/`, `messages/`, `public/locales/`)
+- Key naming convention'ı ne? (flat, nested, namespace-based)
+- Kaç dil destekleniyor?
+- RTL desteği var mı?
+- Tarih/sayı/para birimi formatlama nasıl yapılıyor?
+
+---
+
+## Monorepo Davranışı
+
+### Monorepo Tespit Kriterleri
+
+Şu dosya/klasörlerden biri varsa proje bir monorepo'dur:
+- `pnpm-workspace.yaml`
+- `turbo.json` veya `nx.json`
+- `lerna.json`
+- Kök `package.json` içinde `workspaces` alanı
+- `apps/` ve/veya `packages/` klasör yapısı
+
+### Monorepo Analiz Stratejisi
+
+- `/analyze` monorepo'da verildiğinde: Kök analiz + aktif olarak çalışılan paket/app analizi.
+- Kullanıcı belirli bir paket belirtirse (`/analyze apps/web`), sadece o paket analiz edilir.
+- Kök `project-rules.md` ortak convention'ları (commit format, linting, shared config) içerir.
+- Paket/app `project-rules.md` dosyaları o birime özel override'ları içerir.
+
+### Monorepo Kural Dosyası Hiyerarşisi
+
+```
+monorepo-root/
+├── project-rules.md              ← Tüm paketler için geçerli ortak kurallar
+├── apps/
+│   ├── web/
+│   │   └── project-rules.md      ← Sadece web app'e özel kurallar
+│   └── admin/
+│       └── project-rules.md      ← Sadece admin app'e özel kurallar
+└── packages/
+    ├── ui/
+    │   └── project-rules.md      ← Sadece UI kit'e özel kurallar
+    └── shared/
+        └── project-rules.md      ← Sadece shared pakete özel kurallar
+```
+
+---
+
+## Çıktı Formatı: project-rules.md
+
+Analiz tamamlandıktan sonra aşağıdaki formatta `project-rules.md` oluştur:
+
+```markdown
+# [Proje Adı] — Proje Kuralları
+# Bu dosya otomatik analiz ile oluşturulmuştur.
+# Son analiz tarihi: [TARİH]
+# Analiz tetikleyicisi: [/analyze komutu / Otomatik tespit]
+
+## Proje Özeti
+- **Framework:** [tespit edilen]
+- **Dil:** [TypeScript/JavaScript] | Strict: [Evet/Hayır]
+- **Styling:** [tespit edilen]
+- **State Yönetimi:** [tespit edilen]
+- **Test:** [tespit edilen]
+- **Build Tool:** [tespit edilen]
+- **Monorepo:** [Evet/Hayır]
+- **Fullstack:** [Evet/Hayır — backend katmanı varsa]
+- **i18n:** [Evet/Hayır — kullanılan kütüphane]
+- **Deployment Target:** [tespit edilen]
+
+## Temel Dependency Versiyonları
+- [framework]: [versiyon]
+- [ui-kit]: [versiyon]
+- [state-lib]: [versiyon]
+- [test-runner]: [versiyon]
+
+## Klasör Yapısı Kuralları
+[Mevcut yapıya göre kurallar — yeni dosyalar nereye konulmalı, naming convention'lar]
+
+## Component Kuralları
+[Mevcut koddan tespit edilen pattern'lar — function style, export style, prop tanımlama vs.]
+
+## Styling Kuralları
+[Tailwind config, CSS convention, theme kullanımı vs.]
+
+## Import Kuralları
+[Sıralama, path alias'lar, barrel export kullanımı]
+
+## Tip Tanımlama Kuralları
+[Interface vs Type tercihi, nerede tanımlanacağı, naming convention]
+
+## State Yönetimi Kuralları
+[Hangi state nerede yönetilecek, server state vs client state]
+
+## Test Kuralları
+[Test dosya konumu, naming, minimum kapsam, kullanılan araçlar]
+
+## API & Data Fetching Kuralları
+[Kullanılan pattern'lar, error handling, caching stratejisi]
+
+## Backend/Server Kuralları (Varsa)
+[API route yapısı, validation, auth, DB erişim pattern'ları, server action convention'ları]
+
+## i18n Kuralları (Varsa)
+[Key naming, çeviri dosya yapısı, yeni dil ekleme süreci, çoğullama kuralları]
+
+## Environment & Deployment Kuralları
+[Env variable convention, ortam farkları, build/deploy süreci]
+
+## Design System & UI Kit Kuralları
+[Mevcut component kullanımı, yeni varyant ekleme süreci, token hiyerarşisi]
+
+## Git Kuralları
+[Commit format, branch naming — projeden tespit edilen]
+
+## Proje-Spesifik Notlar
+[Projeye özel convention'lar, dikkat edilmesi gereken noktalar, bilinen teknik borçlar]
+```
+
+### Şablon Esnekliği
+
+Yukarıdaki bölümlerin hepsi her projede geçerli olmayabilir. Analiz sonucunda **ilgisiz bölümleri dahil etme**. Örneğin:
+- Küçük landing page → "State Yönetimi", "Backend/Server", "i18n" bölümleri eklenmez.
+- Sadece frontend → "Backend/Server Kuralları" eklenmez.
+- i18n yoksa → "i18n Kuralları" eklenmez.
+
+Sadece projede aktif olarak kullanılan teknolojilere ve pattern'lara dair bölümleri yaz.
+
+---
+
+## Hata Kurtarma & Fallback
+
+### package.json Yoksa
+1. Projenin bir alt projesi/paketi olabilir → Üst dizinleri kontrol et
+2. Yeni proje mi? → Kullanıcıya sor
+3. Monorepo paketi mi? → Kök dizini bul ve workspace yapısını analiz et
+4. Hiçbiri değilse → Mevcut dosyaları tarayarak teknoloji tahmini yap, kullanıcıya doğrulat
+
+### TypeScript Kullanılmıyorsa
+- TypeScript kurallarını ATLAMA, JavaScript best practice'lerine geç
+- JSDoc ile tip belgeleme öner (zorunlu tutma)
+- PropTypes kullanımını projede varsa devam ettir
+- ESLint kurallarına daha fazla ağırlık ver
+- Kullanıcıya TypeScript migration'ı öner ama dayatma
+
+### Config Dosyası Eksikse
+- tsconfig.json yoksa → Dosya uzantılarından tespit et
+- ESLint config yoksa → Mevcut kod stilinden convention çıkar
+- Prettier config yoksa → Mevcut dosyalardaki formatting'i tespit et
+- .env.example yoksa → Kodda kullanılan env variable'ları tarayarak bir liste oluştur
+
+### Analiz Sırasında Erişilemeyen Dosyalar
+- Erişilemeyen dosyayı atla, analizi durdurmadan devam et
+- Analiz sonucunda "şu dosyalara erişilemedi" notu düş
+- Kritik config dosyasına erişilemiyorsa kullanıcıyı bilgilendir
+
+---
+
+## Güncellik Kontrolü
+
+`project-rules.md` zaten mevcutsa, okurken şunları kontrol et:
+
+1. Analiz tarihi 3 aydan eski mi? → Kullanıcıya güncelleme öner
+2. package.json'daki major versiyonlar rules'daki ile uyuşuyor mu? → Uyuşmuyorsa uyar
+3. Yeni config dosyaları eklenmiş mi? (rules'da olmayan) → Varsa bildir
+4. Klasör yapısı rules'daki ile uyuşuyor mu? → Uyuşmuyorsa güncelleme öner
+
+### Güncelleme Gerektiğinde
+```
+"Proje kurallarınız [tarih]'de oluşturulmuş. O zamandan beri [framework] versiyonu değişmiş
+ve [yeni kütüphane] eklenmiş görünüyor. Kuralları güncellememi ister misiniz? (/analyze)"
+```
+
+### Yeniden Analiz Gerektiren Durumlar
+- Framework major version upgrade'i (ör: Next.js 14 → 15)
+- Yeni major dependency eklenmesi (ör: projeye Zustand eklendi)
+- Klasör yapısı önemli ölçüde değişimi
+- Team convention değişikliği
+- `project-rules.md` 3 aydan eski