contsql 0.2.3__tar.gz → 0.2.9__tar.gz

{contsql-0.2.3 → contsql-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: contsql
-Version: 0.2.3
+Version: 0.2.9
 Requires-Python: >=3.10
 Requires-Dist: duckdb
 Requires-Dist: requests

{contsql-0.2.3 → contsql-0.2.9}/contsql.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: contsql
-Version: 0.2.3
+Version: 0.2.9
 Requires-Python: >=3.10
 Requires-Dist: duckdb
 Requires-Dist: requests

{contsql-0.2.3 → contsql-0.2.9}/contsql.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# v0.2.3 | 2026-04-13 | entity_id+unvan zorunlu kural + slash commands (/s /schema /trace /help)
+# v0.2.9 | 2026-04-13 | JSONL session loglama — her şey kaydedilir, default açık
 """contsql — Minimal DuckDB SQL agent. Soru sor, SQL üret, çalıştır, göster."""
 
 import argparse
@@ -22,6 +22,27 @@ TIMEOUT = int(os.environ.get("CONTSQL_TIMEOUT", "120"))
 
 BANNED_SQL = ["INSERT", "UPDATE", "DELETE", "DROP", "ALTER", "CREATE", "TRUNCATE", "EXEC"]
 
+# ── Loglama ──
+
+_LOG_FILE = None
+
+
+def _init_log(db_path):
+    """Log dosyasını aç. DB'nin yanına contsql_log.jsonl yazar."""
+    global _LOG_FILE
+    log_path = Path(db_path).parent / "contsql_log.jsonl"
+    _LOG_FILE = open(log_path, "a", encoding="utf-8")
+    return log_path
+
+
+def _log(event, **data):
+    """Tek satır JSONL log yaz."""
+    if _LOG_FILE is None:
+        return
+    entry = {"ts": time.strftime("%Y-%m-%d %H:%M:%S"), "event": event, **data}
+    _LOG_FILE.write(json.dumps(entry, ensure_ascii=False) + "\n")
+    _LOG_FILE.flush()
+
 
 # ── Schema discovery ──
 
@@ -45,6 +66,31 @@ def read_schema(conn):
     return "\n".join(lines)
 
 
+def build_column_owner_map(conn):
+    """Her kolonun hangi tablo(lar)da olduğunu çıkar. Açılışta bir kez çalışır."""
+    tables = conn.execute(
+        "SELECT table_name FROM information_schema.tables WHERE table_schema='main'"
+    ).fetchall()
+    col_map = {}
+    for (tname,) in tables:
+        cols = conn.execute(f"""
+            SELECT column_name FROM information_schema.columns
+            WHERE table_schema='main' AND table_name='{tname}'
+        """).fetchall()
+        for (cname,) in cols:
+            col_map.setdefault(cname, []).append(tname)
+    return col_map
+
+
+def format_column_hints(col_map):
+    """Tek tabloya ait kolonları vurgula — bunlar JOIN gerektirir."""
+    lines = ["KOLON SAHİPLİĞİ (JOIN gerektiren kolonlar):"]
+    for col, tables in sorted(col_map.items()):
+        if len(tables) == 1:
+            lines.append(f"  {col} → SADECE {tables[0]}")
+    return "\n".join(lines)
+
+
 def read_domain_notes(db_path):
     """domain_notes.txt veya ews_domain.yaml varsa oku."""
     for name in ("domain_notes.txt", "ews_domain.yaml"):
@@ -73,10 +119,29 @@ def has_reference_trigger(question):
     return any(trigger in q_lower for trigger in REFERANS_TRIGGERS)
 
 
+SORGU_TRIGGERS = [
+    "yanına ekle", "yanına da ekle", "yanına", "buna ekle", "buna da ekle",
+    "kolonu da ekle", "kolonunu da ekle", "bir de", "aynısına",
+    "aynı sorguya", "aynı sorgu", "üstüne ekle", "ekle yanına",
+    "göster yanında", "da göster", "da getir", "de göster", "de getir",
+    "tablodan", "tablodaki", "tabloyu", "tabloya",
+    "çıkart", "çıkar", "kaldır", "at şunu", "filtrele", "daralt",
+    "sadece", "hariç", "hariç tut",
+]
+
+MAX_SQL_CONTEXT_LENGTH = 500
+
+
+def has_query_trigger(question):
+    """Kullanıcı önceki sorguyu modifiye etmek mi istiyor?"""
+    q_lower = question.lower()
+    return any(trigger in q_lower for trigger in SORGU_TRIGGERS)
+
+
 # ── System prompt ──
 
 def build_system_prompt(schema_text, domain_text="", last_result_entities=None,
-                        question=None):
+                        question=None, last_sql=None, column_hints=""):
     prompt = f"""Sen bir SQL asistanısın. Kullanıcının sorusuna uygun SQL yaz.
 
 Kurallar:
@@ -93,11 +158,39 @@ Veritabanı şeması:
 """
     if domain_text:
         prompt += f"\nDomain bilgisi:\n{domain_text}\n"
+    if column_hints:
+        prompt += f"\n{column_hints}\n"
+    if last_sql and question and has_query_trigger(question):
+        if len(last_sql) <= MAX_SQL_CONTEXT_LENGTH:
+            prompt += f"""\nÖNCEKİ SQL'İ MODİFİYE ET:
+
+{last_sql}
+
+KURALLAR:
+1. Yukarıdaki SQL'i TEMEL AL. Sıfırdan sorgu YAZMA.
+2. WHERE koşullarını AYNEN KORU (filtre, LIMIT, entity_id değerleri dahil).
+3. JOIN'leri AYNEN KORU. Yeni kolon için ek JOIN gerekiyorsa EKLE ama mevcutları ÇIKARMA.
+4. Sadece istenen değişikliği yap:
+   - "ekle" / "göster" → SELECT'e kolon ekle
+   - "çıkar" / "kaldır" → SELECT'ten kolon çıkar
+   - "filtrele" / "sadece" → WHERE'e koşul ekle
+5. LIMIT varsa KORU. ORDER BY varsa KORU.
+6. Kolon eklerken dönem belirsizse son dönemi kullan: f.donem = (SELECT MAX(donem) FROM fact_periodic). Tüm dönemleri getirme.
+"""
     if last_result_entities and question and has_reference_trigger(question):
-        prompt += (
-            f"\nÖNCEKİ SORGU SONUCUNDAKI FİRMALAR (entity_id): {last_result_entities}\n"
-            "Bu entity_id listesini WHERE koşulunda kullan.\n"
-        )
+        ids = last_result_entities
+        ids_quoted = ", ".join(str(eid) for eid in ids)
+        prompt += f"""\nÖNCEKİ SORGU FİRMALARI (entity_id): {ids}
+
+Bu entity_id değerlerini SQL'de DOĞRUDAN yaz.
+DOĞRU: WHERE fp.entity_id IN ({ids_quoted})
+YANLIŞ: WHERE entity_id = :muta
+YANLIŞ: WHERE entity_id = 'MUTA_DEGERI'
+YANLIŞ: WHERE entity_id = '1234567890'
+
+Placeholder, parametre, bind variable, örnek değer KULLANMA.
+Gerçek entity_id değerlerini doğrudan SQL string'ine yaz.
+"""
     return prompt
 
 
@@ -117,6 +210,9 @@ def extract_sql(response_text):
 
 def _like_to_ilike(sql):
     """LIKE → ILIKE guardrail. String literal içindekilere dokunmaz."""
+    # ILIKE(col, pattern) fonksiyon syntax'ini col ILIKE pattern'e çevir
+    sql = re.sub(r'\bILIKE\s*\(\s*(\w+\.?\w*)\s*,\s*', r'\1 ILIKE ', sql,
+                 flags=re.IGNORECASE)
     return re.sub(
         r"""(?x)
         (                           # Grup 1: string literal — atla
@@ -170,24 +266,77 @@ def ask_model(system_prompt, question):
         return f"LLM HATA: {e}", time.time() - t0, 0
 
 
-def generate_sql(conn, question, last_result_entities=None, domain_text=""):
+def _short_error(msg):
+    """Trace için kısa hata özeti."""
+    first = str(msg).split('\n')[0]
+    return first[:77] + "..." if len(first) > 80 else first
+
+
+def _extract_column_hint(error_message, col_map):
+    """Hata mesajından kolon adını çıkar, doğru tabloyu bul."""
+    err = str(error_message)
+    m = re.search(r'[Cc]olumn "(\w+)" not found', err)
+    if not m:
+        m = re.search(r'does not have a column named "(\w+)"', err)
+    if not m:
+        return None
+    col_name = m.group(1)
+    if col_name not in col_map:
+        return f"'{col_name}' kolonu veritabanında hiç yok. Schema'yı kontrol et."
+    owners = col_map[col_name]
+    if len(owners) == 1:
+        return (f"'{col_name}' kolonu SADECE '{owners[0]}' tablosundadır. "
+                f"JOIN {owners[0]} ... yapıp {owners[0]}.{col_name} olarak eriş.")
+    tables_str = ", ".join(owners)
+    return (f"'{col_name}' kolonu şu tablolarda var: {tables_str}. "
+            f"Doğru tabloyu JOIN ile ekle ve tablo alias'ı kullan.")
+
+
+def _build_retry_prompt(question, failed_sql, error_message, col_map=None):
+    """Hata sonrası modele gönderilecek retry prompt."""
+    hint_block = ""
+    if col_map:
+        hint = _extract_column_hint(error_message, col_map)
+        if hint:
+            hint_block = f"\n\nİPUCU: {hint}\n"
+
+    return f"""Kullanıcı sorusu: {question}
+
+Ürettiğin SQL hata verdi:
+
+SQL:
+{failed_sql}
+
+Hata:
+{error_message}
+{hint_block}
+Bu hatayı düzelt ve yeni SQL yaz. Kurallar:
+- Hata mesajındaki ipucunu kullan
+- Doğru tabloyu JOIN ile ekle
+- Her kolon referansında tablo alias'ı kullan
+- Placeholder, parametre, bind variable KULLANMA — gerçek değerleri yaz
+- Sadece düzeltilmiş SQL yaz, açıklama yapma
+"""
+
+
+def generate_sql(conn, question, last_result_entities=None, domain_text="",
+                 col_map=None):
     """Soru → SQL string. Test runner için callable. Başarısızsa None."""
     schema_text = read_schema(conn)
+    column_hints = format_column_hints(col_map) if col_map else ""
     system_prompt = build_system_prompt(schema_text, domain_text, last_result_entities,
-                                       question=question)
+                                       question=question, column_hints=column_hints)
     response, _, _ = ask_model(system_prompt, question)
     sql = extract_sql(response)
     if not sql or check_sql_safety(sql):
         return None
     sql = _like_to_ilike(sql)
 
-    # Ambiguous column retry: EXPLAIN ile ön kontrol
+    # Genel SQL hata retry: EXPLAIN ile ön kontrol
     try:
         conn.execute(f"EXPLAIN {sql}")
     except Exception as e:
-        if "ambiguous" not in str(e).lower():
-            return sql
-        retry_q = f"{question}\n\nÖNCEKİ SQL HATA: {e}\nJOIN'de tablo alias kullan."
+        retry_q = _build_retry_prompt(question, sql, e, col_map)
         resp2, _, _ = ask_model(system_prompt, retry_q)
         sql2 = extract_sql(resp2)
         if sql2 and not check_sql_safety(sql2):
@@ -265,10 +414,12 @@ def _extract_entity_ids(columns, rows, max_entities=100):
     return ids or None
 
 
-def run_query(conn, system_prompt, question):
-    """Tek soru → SQL → çalıştır → sonuç. entity_id listesi döndürür."""
+def run_query(conn, system_prompt, question, col_map=None):
+    """Tek soru → SQL → çalıştır → sonuç. (entity_id listesi, sql) tuple döndürür."""
     # 1. Model'e sor
     response, elapsed, tokens = ask_model(system_prompt, question)
+    _log("model", question=question, elapsed=round(elapsed, 1), tokens=tokens,
+         response=response)
 
     print(f"\n💭 MODEL ({elapsed:.1f}s, ~{tokens} tok)")
     if not response.startswith("LLM HATA"):
@@ -281,14 +432,16 @@ def run_query(conn, system_prompt, question):
     if not sql:
         print(f"\n❌ Model SQL üretmedi:")
         print(f"   {response[:300]}")
-        return None
+        _log("no_sql", question=question)
+        return None, None
 
     # 3. Güvenlik kontrolü
     safety_error = check_sql_safety(sql)
     if safety_error:
         print(f"\n⛔ {safety_error}")
         print(f"🔍 SQL: {sql[:200]}")
-        return None
+        _log("safety", question=question, sql=sql, error=safety_error)
+        return None, None
 
     # 3b. LIKE → ILIKE guardrail
     sql = _like_to_ilike(sql)
@@ -305,37 +458,47 @@ def run_query(conn, system_prompt, question):
 
         print(f"\n📊 SONUÇ ({len(rows)} satır, {query_ms:.0f}ms)")
         print(format_table(columns, rows))
+        if len(rows) > 50:
+            print(f"  ⚠ {len(rows)} satır döndü, ilk 50 gösteriliyor. Soruyu daraltın.")
 
         # Entity context çıkar
         entities = _extract_entity_ids(columns, rows)
         if entities is None and len(rows) > 100:
-            print("  ⚠ Önceki sorgu çok geniş — firma referansı için soruyu daraltın.")
-        return entities
+            print("  ⚠ Firma referansı için soruyu daraltın (max 100 entity).")
+        _log("ok", question=question, sql=sql, row_count=len(rows),
+             query_ms=round(query_ms), columns=columns)
+        return entities, sql
     except duckdb.Error as e:
-        # Ambiguous column retry
-        if "ambiguous" in str(e).lower():
-            print(f"🔄 Ambiguous column, retry...")
-            retry_q = f"{question}\n\nSQL HATA: {e}\nJOIN'de tablo alias kullan."
-            resp2, _, _ = ask_model(system_prompt, retry_q)
-            sql2 = extract_sql(resp2)
-            if sql2 and not check_sql_safety(sql2):
-                sql2 = _like_to_ilike(sql2)
-                print(f"🔍 Retry SQL: {sql2}")
-                try:
-                    result = conn.execute(sql2)
-                    columns = [desc[0] for desc in result.description]
-                    rows = result.fetchall()
-                    query_ms = (time.time() - t0) * 1000
-                    print(f"\n📊 SONUÇ ({len(rows)} satır, {query_ms:.0f}ms)")
-                    print(format_table(columns, rows))
-                    entities = _extract_entity_ids(columns, rows)
-                    return entities
-                except duckdb.Error as e2:
-                    print(f"\n❌ Retry hatası: {e2}")
-                    return None
+        _log("error", question=question, sql=sql, error=str(e))
+        # Genel SQL hata retry — tek retry, her hata tipinde
+        print(f"🔄 Retry ({_short_error(e)})...")
+        retry_q = _build_retry_prompt(question, sql, e, col_map)
+        resp2, _, _ = ask_model(system_prompt, retry_q)
+        sql2 = extract_sql(resp2)
+        if sql2 and not check_sql_safety(sql2):
+            sql2 = _like_to_ilike(sql2)
+            print(f"🔍 Retry SQL: {sql2}")
+            try:
+                result = conn.execute(sql2)
+                columns = [desc[0] for desc in result.description]
+                rows = result.fetchall()
+                query_ms = (time.time() - t0) * 1000
+                print(f"\n📊 SONUÇ ({len(rows)} satır, {query_ms:.0f}ms)")
+                print(format_table(columns, rows))
+                entities = _extract_entity_ids(columns, rows)
+                if entities is None and len(rows) > 100:
+                    print("  ⚠ Önceki sorgu çok geniş — firma referansı için soruyu daraltın.")
+                _log("retry_ok", question=question, original_sql=sql,
+                     retry_sql=sql2, row_count=len(rows), columns=columns)
+                return entities, sql2
+            except duckdb.Error as e2:
+                print(f"\n❌ Retry de başarısız: {_short_error(e2)}")
+                _log("retry_fail", question=question, original_sql=sql,
+                     retry_sql=sql2, error=str(e2))
+                return None, None
         print(f"\n❌ SQL hatası: {e}")
         print(f"🔍 SQL: {sql}")
-        return None
+        return None, None
 
 
 def handle_slash_command(cmd, state):
@@ -344,7 +507,9 @@ def handle_slash_command(cmd, state):
 
     if cmd == "/s":
         state["last_result_entities"] = None
+        state["last_sql"] = None
         print("🧹 Bellek temizlendi.")
+        _log("cmd", cmd="/s")
         return True
 
     if cmd == "/schema":
@@ -368,13 +533,16 @@ def handle_slash_command(cmd, state):
     return False
 
 
-def interactive_loop(conn, schema_text, domain_text):
+def interactive_loop(conn, schema_text, domain_text, col_map):
     """REPL döngüsü."""
     print(f"\ncontsql hazır. Model: {MODEL} | /help komutlar")
     print("Çıkmak için: quit/exit/q\n")
 
+    column_hints = format_column_hints(col_map)
+
     state = {
         "last_result_entities": None,
+        "last_sql": None,
         "trace": False,
         "schema_text": schema_text,
     }
@@ -396,12 +564,21 @@ def interactive_loop(conn, schema_text, domain_text):
                 print(f"Bilinmeyen komut: {question}. /help yazın.")
             continue
 
+        # SQL context uzunluk uyarısı
+        if state["last_sql"] and has_query_trigger(question) \
+                and len(state["last_sql"]) > MAX_SQL_CONTEXT_LENGTH:
+            print("⚠ Önceki sorgu çok uzun — lütfen soruyu tam yazın.")
+
         system_prompt = build_system_prompt(schema_text, domain_text,
                                            state["last_result_entities"],
-                                           question=question)
-        entities = run_query(conn, system_prompt, question)
+                                           question=question,
+                                           last_sql=state["last_sql"],
+                                           column_hints=column_hints)
+        entities, sql = run_query(conn, system_prompt, question, col_map)
         if entities is not None:
             state["last_result_entities"] = entities
+        if sql is not None:
+            state["last_sql"] = sql
         print()
 
 
@@ -425,19 +602,26 @@ def main():
 
     conn = duckdb.connect(str(db_path), read_only=True)
 
-    # Schema + domain
+    # Loglama başlat
+    log_path = _init_log(db_path)
+
+    # Schema + domain + column map
     schema_text = read_schema(conn)
     domain_text = read_domain_notes(str(db_path))
+    col_map = build_column_owner_map(conn)
 
-    print(f"DB: {db_path} | Model: {MODEL}")
+    print(f"DB: {db_path} | Model: {MODEL} | Log: {log_path}")
+    _log("session_start", db=str(db_path), model=MODEL)
 
     # Tek soru veya interaktif
     if args.question:
+        column_hints = format_column_hints(col_map)
         system_prompt = build_system_prompt(schema_text, domain_text,
-                                           question=args.question)
-        run_query(conn, system_prompt, args.question)
+                                           question=args.question,
+                                           column_hints=column_hints)
+        run_query(conn, system_prompt, args.question, col_map)
     else:
-        interactive_loop(conn, schema_text, domain_text)
+        interactive_loop(conn, schema_text, domain_text, col_map)
 
     conn.close()
 

{contsql-0.2.3 → contsql-0.2.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "contsql"
-version = "0.2.3"
+version = "0.2.9"
 requires-python = ">=3.10"
 dependencies = ["duckdb", "requests"]