kortext 1.0.0 → 2.2.0

package/scripts/kortext-item-start.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import re
+import shutil
+import subprocess
+from datetime import datetime
+from pathlib import Path
+
+
+BACKLOG_ROOT = Path("workspace/memory/backlog")
+CONTEXT_ROOT = Path("workspace/memory/context")
+
+
+def update_status(content: str, status: str) -> str:
+    return re.sub(r"> \*\*Status:\*\* .*", f"> **Status:** {status}", content, count=1)
+
+
+def _atomic_commit(message: str, paths: list[str]) -> None:
+    # Kortext atomic operation: dosyaları add edip commit'ler.
+    # Git repo değilse, değişiklik yoksa veya hook reddederse sessizce geç.
+    if not shutil.which("git"):
+        return
+    try:
+        subprocess.run(["git", "add", "--", *paths], check=True, capture_output=True)
+        subprocess.run(
+            ["git", "commit", "-m", message, "--", *paths],
+            check=True,
+            capture_output=True,
+        )
+    except subprocess.CalledProcessError:
+        return
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Start a Kortext backlog item")
+    parser.add_argument("item_path")
+    parser.add_argument("--agent", required=True, help="e.g. backend-developer")
+    parser.add_argument("--summary", required=True)
+    parser.add_argument("--no-commit", action="store_true", help="Atomic git commit'i atla")
+    args = parser.parse_args()
+
+    item_path = Path(args.item_path)
+    if not item_path.exists():
+        raise SystemExit(f"Hata: Dosya bulunamadı: {item_path}")
+
+    item_id = item_path.stem.split("-", 1)[0]
+    content = item_path.read_text()
+    item_path.write_text(update_status(content, "In Progress"))
+
+    CONTEXT_ROOT.mkdir(parents=True, exist_ok=True)
+    timestamp = datetime.now().strftime("%H:%M")
+    context_path = CONTEXT_ROOT / f"{args.agent}-active.md"
+    context_path.write_text(
+        f"### +{args.agent} | {item_id} | In Progress | {timestamp} | {args.summary}\n"
+    )
+
+    print(f"✅ Başlatıldı: {item_id}")
+    print(f"✅ Context güncellendi: {context_path}")
+
+    if not args.no_commit:
+        _atomic_commit(
+            f"chore(kortext): start {item_id} [skip ci]",
+            [str(item_path), str(context_path)],
+        )
+
+
+if __name__ == "__main__":
+    main()

package/scripts/kortext-item-transition.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import re
+import shutil
+import subprocess
+from pathlib import Path
+
+
+ALLOWED_TRANSITIONS = {
+    "To Do": {"In Progress"},
+    "In Progress": {"Test"},
+    "Test": {"In Progress", "Review"},
+    "Review": {"In Progress", "Done"},
+    "Done": set(),
+}
+
+
+def read_status(content: str) -> str:
+    match = re.search(r"> \*\*Status:\*\* (.+)", content)
+    if not match:
+        raise SystemExit("Hata: Item dosyasında status alanı bulunamadı.")
+    return match.group(1).strip()
+
+
+def write_status(content: str, status: str) -> str:
+    return re.sub(r"> \*\*Status:\*\* .*", f"> **Status:** {status}", content, count=1)
+
+
+def _atomic_commit(message: str, paths: list[str]) -> None:
+    # Kortext atomic operation: dosyaları add edip commit'ler.
+    if not shutil.which("git"):
+        return
+    try:
+        subprocess.run(["git", "add", "--", *paths], check=True, capture_output=True)
+        subprocess.run(
+            ["git", "commit", "-m", message, "--", *paths],
+            check=True,
+            capture_output=True,
+        )
+    except subprocess.CalledProcessError:
+        return
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Transition a Kortext item status")
+    parser.add_argument("item_path")
+    parser.add_argument("--to", required=True, choices=sorted(ALLOWED_TRANSITIONS))
+    parser.add_argument("--no-commit", action="store_true", help="Atomic git commit'i atla")
+    args = parser.parse_args()
+
+    item_path = Path(args.item_path)
+    if not item_path.exists():
+        raise SystemExit(f"Hata: Dosya bulunamadı: {item_path}")
+
+    content = item_path.read_text()
+    current = read_status(content)
+    allowed = ALLOWED_TRANSITIONS.get(current)
+    if allowed is None:
+        raise SystemExit(f"Hata: Geçersiz mevcut status: {current}")
+    if args.to not in allowed:
+        raise SystemExit(f"Hata: Geçersiz geçiş: {current} -> {args.to}")
+
+    item_path.write_text(write_status(content, args.to))
+    print(f"✅ Geçiş yapıldı: {current} -> {args.to}")
+
+    if not args.no_commit:
+        item_id = item_path.stem.split("-", 1)[0]
+        slug = args.to.lower().replace(" ", "-")
+        _atomic_commit(
+            f"chore(kortext): transition {item_id} -> {slug} [skip ci]",
+            [str(item_path)],
+        )
+
+
+if __name__ == "__main__":
+    main()

package/scripts/kortext-lock.py

@@ -0,0 +1,174 @@
+#!/usr/bin/env python3
+"""
+Kortext File Lock
+-----------------
+Paylaşımlı dosyalara (handover.md, epic-dashboard.md vb.) eş zamanlı yazma
+çakışmasını önlemek için dosya kilidi mekanizması sağlar.
+
+Kullanım:
+  # Kilitlemek için:
+  python kortext-lock.py acquire --file workspace/memory/handover.md --agent backend-developer
+
+  # Kilidi serbest bırakmak için:
+  python kortext-lock.py release --file workspace/memory/handover.md
+
+  # Kilit durumunu kontrol etmek için:
+  python kortext-lock.py status --file workspace/memory/handover.md
+"""
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from datetime import datetime, timedelta
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+LOCK_DIR = ROOT / "workspace/.locks"
+
+# Saniye cinsinden lock timeout. Env var ile override edilebilir.
+# Default: 300 saniye = 5 dakika.
+LOCK_TIMEOUT_SECONDS = int(os.environ.get("KORTEXT_LOCK_TIMEOUT_SECONDS", "300"))
+LOCK_TIMEOUT_MINUTES = LOCK_TIMEOUT_SECONDS / 60
+
+
+def lock_path(target_file: str) -> Path:
+    safe_name = target_file.replace("/", "_").replace("\\", "_")
+    return LOCK_DIR / f"{safe_name}.lock"
+
+
+def acquire(target_file: str, agent: str) -> None:
+    LOCK_DIR.mkdir(parents=True, exist_ok=True)
+    lp = lock_path(target_file)
+
+    # Stale lock kontrolü — saniye bazında karşılaştırılır.
+    if lp.exists():
+        content = lp.read_text(errors="ignore")
+        lines = content.splitlines()
+        # Zaman damgasını parse et
+        time_line = next((l for l in lines if l.startswith("time:")), None)
+        if time_line:
+            try:
+                lock_time = datetime.fromisoformat(time_line.split(":", 1)[1].strip())
+                age = datetime.now() - lock_time
+                if age > timedelta(seconds=LOCK_TIMEOUT_SECONDS):
+                    print(
+                        f"⚠️  Stale kilit tespit edildi ({round(age.total_seconds()/60, 1)} dakika). "
+                        f"Otomatik kaldırılıyor..."
+                    )
+                    lp.unlink()
+                else:
+                    owner_line = next((l for l in lines if l.startswith("agent:")), "agent: bilinmiyor")
+                    owner = owner_line.split(":", 1)[1].strip()
+                    # Türkçe hata mesajı stderr'e — fail durumunda exit 1.
+                    print(
+                        f"🔒 Kilit alınamadı: {target_file} — sahibi: +{owner}, "
+                        f"son güncelleme: {lock_time.strftime('%Y-%m-%d %H:%M:%S')}",
+                        file=sys.stderr,
+                    )
+                    print(
+                        f"   Otomatik açılır: {round(LOCK_TIMEOUT_MINUTES, 1)} dakika sonra",
+                        file=sys.stderr,
+                    )
+                    sys.exit(1)
+            except (ValueError, IndexError):
+                # Parse edilemezse stale say
+                lp.unlink()
+
+    # Kilidi al
+    now = datetime.now()
+    lp.write_text(
+        f"agent: {agent}\n"
+        f"file: {target_file}\n"
+        f"time: {now.isoformat()}\n"
+    )
+    print(f"✅ Kilit alındı: {target_file} (+{agent})")
+
+
+def release(target_file: str) -> None:
+    lp = lock_path(target_file)
+    if lp.exists():
+        lp.unlink()
+        print(f"✅ Kilit kaldırıldı: {target_file}")
+    else:
+        print(f"ℹ️  Kilit zaten yok: {target_file}")
+
+
+def status(target_file: str) -> None:
+    lp = lock_path(target_file)
+    if not lp.exists():
+        print(f"🔓 Serbest: {target_file}")
+        return
+
+    content = lp.read_text(errors="ignore")
+    lines = content.splitlines()
+    agent_line = next((l for l in lines if l.startswith("agent:")), "agent: bilinmiyor")
+    time_line = next((l for l in lines if l.startswith("time:")), None)
+    agent = agent_line.split(":", 1)[1].strip()
+    if time_line:
+        try:
+            lock_time = datetime.fromisoformat(time_line.split(":", 1)[1].strip())
+            age = datetime.now() - lock_time
+            stale = age > timedelta(seconds=LOCK_TIMEOUT_SECONDS)
+            stale_flag = " ⚠️ STALE" if stale else ""
+            print(f"🔒 Kilitli: {target_file}")
+            print(f"   Sahibi: +{agent}")
+            print(f"   Süre  : {round(age.total_seconds()/60, 1)} dakika{stale_flag}")
+        except (ValueError, IndexError):
+            print(f"🔒 Kilitli (parse hatası): {target_file}")
+    else:
+        print(f"🔒 Kilitli: {target_file} (+{agent})")
+
+
+def list_all() -> None:
+    if not LOCK_DIR.exists():
+        print("ℹ️  Aktif kilit yok.")
+        return
+    locks = list(LOCK_DIR.glob("*.lock"))
+    if not locks:
+        print("ℹ️  Aktif kilit yok.")
+        return
+    print(f"🔒 Aktif kilitler ({len(locks)} adet):")
+    for lp in sorted(locks):
+        content = lp.read_text(errors="ignore")
+        lines = content.splitlines()
+        agent_line = next((l for l in lines if l.startswith("agent:")), "agent: ?")
+        file_line = next((l for l in lines if l.startswith("file:")), "file: ?")
+        agent = agent_line.split(":", 1)[1].strip()
+        file_ref = file_line.split(":", 1)[1].strip()
+        print(f"  • {file_ref} → +{agent}")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Kortext File Lock Manager")
+    sub = parser.add_subparsers(dest="command")
+
+    acq = sub.add_parser("acquire", help="Dosya kilidi al")
+    acq.add_argument("--file", required=True, help="Kilitlenecek dosya yolu")
+    acq.add_argument("--agent", required=True, help="Kilidi alan ajan (örn: backend-developer)")
+
+    rel = sub.add_parser("release", help="Dosya kilidini kaldır")
+    rel.add_argument("--file", required=True, help="Kilidi kaldırılacak dosya yolu")
+
+    stat = sub.add_parser("status", help="Dosya kilit durumu")
+    stat.add_argument("--file", required=True, help="Kontrol edilecek dosya yolu")
+
+    sub.add_parser("list", help="Tüm aktif kilitleri listele")
+
+    args = parser.parse_args()
+
+    if args.command == "acquire":
+        acquire(args.file, args.agent)
+    elif args.command == "release":
+        release(args.file)
+    elif args.command == "status":
+        status(args.file)
+    elif args.command == "list":
+        list_all()
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

package/scripts/kortext-session-start.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+"""
+Kortext Session Start
+---------------------
+Her oturum açılışında çalışır. Context dosyalarını okur, handover'ı kontrol eder
+ve SESSION_BRIEF üretir. Ajan bu özeti görmeden göreve başlamamalıdır.
+"""
+from __future__ import annotations
+
+import os
+from datetime import datetime, timedelta
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+CONTEXT_DIR = ROOT / "workspace/memory/context"
+HANDOVER_PATH = ROOT / "workspace/memory/handover.md"
+BACKLOG_DIR = ROOT / "workspace/memory/backlog"
+
+# Stale eşiği saat cinsinden. Env var ile override edilebilir.
+STALE_HOURS = int(os.environ.get("KORTEXT_STALE_HOURS_CONTEXT", "24"))
+
+
+def read_context_files() -> list[dict]:
+    """Tüm aktif context dosyalarını okur."""
+    agents = []
+    if not CONTEXT_DIR.exists():
+        return agents
+    for f in sorted(CONTEXT_DIR.glob("*-active.md")):
+        if f.name.startswith("["):  # şablon dosyalarını atla
+            continue
+        content = f.read_text(errors="ignore").strip()
+        mtime = datetime.fromtimestamp(f.stat().st_mtime)
+        age_hours = (datetime.now() - mtime).total_seconds() / 3600
+        agents.append({
+            "file": f.name,
+            "content": content,
+            "age_hours": round(age_hours, 1),
+            "stale": age_hours > STALE_HOURS,
+        })
+    return agents
+
+
+def read_last_handover() -> str:
+    """handover.md dosyasından en son handover bloğunu döndürür."""
+    if not HANDOVER_PATH.exists():
+        return "(handover.md bulunamadı)"
+    text = HANDOVER_PATH.read_text(errors="ignore")
+    # İlk ## Handover: bloğunu bul
+    lines = text.splitlines()
+    block: list[str] = []
+    in_block = False
+    for line in lines:
+        if line.startswith("## Handover:"):
+            if in_block:
+                break  # Sadece ilk (en yeni) bloğu al
+            in_block = True
+        if in_block:
+            block.append(line)
+    return "\n".join(block) if block else "(kayıtlı handover yok)"
+
+
+def count_in_progress_items() -> list[str]:
+    """Backlog'da In Progress olan itemları döndürür."""
+    items = []
+    if not BACKLOG_DIR.exists():
+        return items
+    for f in BACKLOG_DIR.glob("*.md"):
+        text = f.read_text(errors="ignore")
+        if "**Status:** In Progress" in text:
+            items.append(f.stem)
+    return items
+
+
+def main() -> None:
+    now = datetime.now().strftime("%d.%m.%Y %H:%M")
+    print("=" * 60)
+    print(f"  KORTEXT SESSION BRIEF — {now}")
+    print("=" * 60)
+
+    # 1. Aktif ajanlar
+    agents = read_context_files()
+    print(f"\n📋 AKTİF AJANLAR ({len(agents)} dosya):")
+    if not agents:
+        print("  → Context dosyası yok. Temiz başlangıç.")
+    for agent in agents:
+        stale_flag = " ⚠️ STALE" if agent["stale"] else ""
+        print(f"  • {agent['file']} ({agent['age_hours']}s önce güncellendi{stale_flag})")
+        # İlk satırı özetle
+        first_line = agent["content"].splitlines()[0] if agent["content"] else ""
+        if first_line:
+            print(f"    {first_line}")
+
+    # 2. In Progress itemlar
+    in_progress = count_in_progress_items()
+    print(f"\n🔄 IN PROGRESS İTEMLAR ({len(in_progress)} adet):")
+    if not in_progress:
+        print("  → Yok.")
+    for item in in_progress:
+        print(f"  • {item}")
+
+    # 3. Son handover
+    print(f"\n📨 SON HANDOVER:")
+    handover = read_last_handover()
+    # İlk 10 satırı göster
+    preview_lines = handover.splitlines()[:10]
+    for line in preview_lines:
+        print(f"  {line}")
+    if len(handover.splitlines()) > 10:
+        print(f"  ... ({len(handover.splitlines())} satır — tam okuma için handover.md)")
+
+    # 4. Stale uyarıları
+    stale_agents = [a for a in agents if a["stale"]]
+    if stale_agents:
+        print(f"\n⚠️  STALE CONTEXT UYARISI ({len(stale_agents)} dosya):")
+        for a in stale_agents:
+            print(f"  • {a['file']} — {a['age_hours']} saat önce güncellendi")
+        print("  → Bu dosyalar hala In Progress görünüyor. Kontrol et.")
+
+    print("\n" + "=" * 60)
+    print("  Context yüklendi. Göreve başlamadan önce yukarıdaki")
+    print("  bilgileri oku ve durumu anla.")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()

package/scripts/lock_kortext.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+KORTEXT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+KORTEXT_ROOT="$(cd "$KORTEXT_DIR/.." && pwd)"
+
+# Bu script Kortext Framework'ün kritik dosyalarını sadece okunabilir hale getirir.
+
+# Kök dizin dosyaları
+FILES=("$KORTEXT_DIR/AGENTS.md")
+
+# Korumaya alınacak Framework klasörleri
+DIRS="$KORTEXT_DIR/agents $KORTEXT_DIR/rules $KORTEXT_DIR/workflows"
+
+echo "Kortext Framework dosyaları kilitleniyor..."
+
+# Dosyaları kilitle
+for FILE in "${FILES[@]}"; do
+    if [ -f "$FILE" ]; then
+        echo "- $FILE kilitleniyor..."
+        chmod 444 "$FILE"
+    fi
+done
+
+# Klasörleri ve içindekileri kilitle (Yazma yetkisini kaldır, okuma ve erişim yetkisini koru)
+for DIR in $DIRS; do
+    if [ -d "$DIR" ]; then
+        echo "- $DIR klasörü ve içeriği kilitleniyor..."
+        chmod -R a-w "$DIR"
+        chmod -R a+rX "$DIR"
+    fi
+done
+
+echo "İşlem tamamlandı. Framework dosyaları artık sadece okunabilir."

package/settings/.claude-settings.template.json

@@ -0,0 +1,48 @@
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Write|Edit",
+        "hooks": [
+          { "type": "command", "command": "${KORTEXT_ROOT}/hooks/write-guard.sh" },
+          { "type": "command", "command": "${KORTEXT_ROOT}/hooks/secret-scanner.sh" },
+          { "type": "command", "command": "${KORTEXT_ROOT}/hooks/auto-locker.sh" },
+          { "type": "command", "command": "${KORTEXT_ROOT}/hooks/snapshot-guard.sh" }
+        ]
+      },
+      {
+        "matcher": "Bash",
+        "hooks": [
+          { "type": "command", "command": "${KORTEXT_ROOT}/hooks/secret-scanner.sh" }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Write|Edit",
+        "hooks": [
+          { "type": "command", "command": "${KORTEXT_ROOT}/hooks/auto-unlocker.sh" },
+          { "type": "command", "command": "${KORTEXT_ROOT}/hooks/audit-logger.sh" }
+        ]
+      },
+      {
+        "matcher": "*",
+        "hooks": [
+          { "type": "command", "command": "${KORTEXT_ROOT}/hooks/audit-logger.sh" }
+        ]
+      }
+    ],
+    "SessionStart": [
+      {
+        "hooks": [
+          { "type": "command", "command": "python3 ${KORTEXT_ROOT}/scripts/kortext-session-start.py" }
+        ]
+      }
+    ]
+  },
+  "env": {
+    "KORTEXT_HOOK_MODE": "permissive",
+    "KORTEXT_INTERACTION_LANGUAGE": "tr",
+    "KORTEXT_RUNTIME": "claude_code"
+  }
+}