Upload 10 files

argument_analyzer.py

@@ -0,0 +1,101 @@
+# argument_analyzer.py (V2 - Adım 2.2 Düzeltilmiş Hali - Tekrar)
+import spacy
+from spacy.tokens import Doc, Span, Token
+from typing import List, Tuple, Dict, Set
+import data_models # Düz yapı importu
+from rich.console import Console
+
+console = Console()
+
+# --- Göstergeler ---
+CLAIM_INDICATORS_VERBS = {"believe", "think", "argue", "claim", "suggest", "conclude", "state", "assert", "maintain", "propose", "insist", "contend", "show", "demonstrate", "indicate"}
+CLAIM_INDICATORS_PHRASES = {"in my opinion", "it seems that", "the main point is", "it is clear that", "clearly", "the conclusion is", "we must", "it is necessary", "it is evident that"}
+MODAL_VERBS_STRONG = {"should", "must", "ought", "has to", "needs to"}
+PREMISE_INDICATORS = {"because", "since", "as", "for", "given that", "due to", "owing to", "assuming that", "the reason is", "if"}
+
+# --- Dependency Parsing Yardımcı Fonksiyonları ---
+def find_root_verb(sent: Span) -> Token | None:
+    for token in sent:
+        if token.dep_ == "ROOT" and token.pos_ == "VERB": return token
+    for token in sent:
+         if token.dep_ == "ROOT" and token.pos_ == "AUX": return token
+    return None
+
+def has_subject(verb: Token) -> bool:
+    return any(child.dep_ in {"nsubj", "nsubjpass"} for child in verb.children)
+
+def has_complement_or_object(verb: Token) -> bool:
+    return any(child.dep_ in {"dobj", "attr", "acomp", "ccomp", "xcomp", "pobj"} for child in verb.children)
+
+def get_clause_starting_with(indicator: str, sent: Span) -> Span | None:
+     indicator_token = None
+     for token in sent:
+          if token.text.lower() == indicator and token.dep_ in {"mark", "prep", "agent"}:
+               indicator_token = token; break
+     if indicator_token:
+          start_char = indicator_token.idx; end_char = sent.end_char
+          clause_span = sent.doc.char_span(start_char, end_char)
+          return clause_span if clause_span else sent
+     return None
+
+# --- Gelişmiş Analiz Fonksiyonu (Düzeltilmiş Hali) ---
+def enhanced_component_analyzer(doc: Doc) -> List[data_models.ArgumentComponent]:
+    """
+    spaCy Doc nesnesini analiz ederek dependency parsing ve göstergelerle
+    potansiyel iddia ve gerekçeleri tespit eder (V2 - Düzeltilmiş).
+    """
+    components = []
+    sentences = list(doc.sents)
+
+    for i, sent in enumerate(sentences):
+        sent_text_lower = sent.text.lower()
+        potential_components_in_sentence: List[Tuple[str, float, Span]] = []
+        premise_found_in_this_sentence = False
+
+        # --- 1. Gerekçe Kontrolü ---
+        for indicator in PREMISE_INDICATORS:
+            if f" {indicator} " in f" {sent_text_lower} " or sent_text_lower.startswith(f"{indicator} "):
+                span_to_use = sent # Şimdilik tüm cümleyi al
+                potential_components_in_sentence.append(("Premise", 0.65, span_to_use))
+                premise_found_in_this_sentence = True
+                break
+
+        if premise_found_in_this_sentence:
+            comp_type, confidence, span = potential_components_in_sentence[0]
+            components.append(data_models.ArgumentComponent(
+                 component_type=comp_type, text=span.text, sentence_index=i,
+                 span_start=span.start_char, span_end=span.end_char, confidence=confidence
+            ))
+            continue # Diğer cümleye geç
+
+        # --- Gerekçe bulunamadıysa İddia Kontrolleri ---
+        claim_indicator_confidence = 0.0
+        has_claim_verb = any(token.lemma_ in CLAIM_INDICATORS_VERBS and token.pos_ == "VERB" for token in sent)
+        has_modal = any(token.lemma_ in MODAL_VERBS_STRONG and token.pos_ == "AUX" for token in sent)
+        has_claim_phrase = any(phrase in sent_text_lower for phrase in CLAIM_INDICATORS_PHRASES)
+        if has_claim_verb: claim_indicator_confidence = max(claim_indicator_confidence, 0.5)
+        if has_modal: claim_indicator_confidence = max(claim_indicator_confidence, 0.6)
+        if has_claim_phrase: claim_indicator_confidence = max(claim_indicator_confidence, 0.7)
+        if claim_indicator_confidence > 0:
+             potential_components_in_sentence.append(("Claim", claim_indicator_confidence, sent))
+
+        root_verb = find_root_verb(sent)
+        if root_verb:
+            if has_subject(root_verb) and has_complement_or_object(root_verb):
+                 if not any(c[0] == "Claim" for c in potential_components_in_sentence):
+                      potential_components_in_sentence.append(("Claim", 0.4, sent))
+
+        best_component = None; max_confidence = 0.0
+        for comp_type, confidence, span in potential_components_in_sentence:
+             if confidence > max_confidence:
+                  max_confidence = confidence; best_component = (comp_type, span)
+
+        if best_component:
+            comp_type, span = best_component
+            components.append(data_models.ArgumentComponent(
+                 component_type=comp_type, text=span.text, sentence_index=i,
+                 span_start=span.start_char, span_end=span.end_char, confidence=max_confidence
+            ))
+
+    console.print(f" -> Enhanced Analyzer (Corrected Version) found {len(components)} potential components.", style="dim")
+    return components

argument_visualizer.py

@@ -0,0 +1,108 @@
+# argument_visualizer.py (V2/V3 - Adım 3.1: Düşük Eşik Denemesi)
+import networkx as nx
+from typing import List, Dict
+import data_models
+from rich.console import Console
+import textwrap
+import torch
+import torch.nn.functional as F
+
+console = Console()
+
+# Anlamsal Benzerlik Eşiği DÜŞÜRÜLDÜ!
+LINKING_SIMILARITY_THRESHOLD = 0.55 # Önceki 0.65 idi, şimdi 0.55 deneyelim
+
+# --- Yardımcı Fonksiyon: Benzerlik Hesaplama (Aynı) ---
+def calculate_similarity(emb1: torch.Tensor | None, emb2: torch.Tensor | None) -> float | None:
+     if emb1 is None or emb2 is None: return None
+     emb1 = emb1.cpu(); emb2 = emb2.cpu()
+     if emb1.dim() == 1: emb1 = emb1.unsqueeze(0)
+     if emb2.dim() == 1: emb2 = emb2.unsqueeze(0)
+     try: return F.cosine_similarity(emb1, emb2).item()
+     except Exception as e: console.print(f"[yellow]Warn: Cosine similarity failed: {e}[/yellow]"); return None
+
+# --- Ana Grafik Oluşturma Fonksiyonu (Aynı) ---
+def build_argument_graph(
+    components: List[data_models.ArgumentComponent],
+    sentence_embeddings: List[torch.Tensor | None]
+) -> nx.DiGraph | None:
+    # ... (Fonksiyonun geri kalanı bir önceki mesajdakiyle aynı)...
+    if not components: return None
+    G = nx.DiGraph()
+    claims = []; premises = []
+    for i, comp in enumerate(components):
+        node_id = f"{comp.component_type[0]}{i+1}"
+        conf_str = f" (Conf: {comp.confidence:.2f})" if comp.confidence is not None else ""
+        node_label = f"\"{textwrap.shorten(comp.text, width=35, placeholder='...')}\"{conf_str}"
+        node_shape = "()" if comp.component_type == "Claim" else "[]"
+        G.add_node(node_id, label=node_label, type=comp.component_type, shape=node_shape, component_index=i, sentence_index=comp.sentence_index)
+        if comp.component_type == "Claim": claims.append((i, node_id, comp.sentence_index))
+        else: premises.append((i, node_id, comp.sentence_index))
+
+    if not claims or not premises:
+        console.print(" -> Argument graph requires at least one claim and one premise to show structure.", style="dim")
+        return G
+
+    edges_added = 0
+    for p_comp_idx, p_node_id, p_sent_idx in premises:
+        if not (0 <= p_sent_idx < len(sentence_embeddings)): continue
+        premise_embedding = sentence_embeddings[p_sent_idx]
+        if premise_embedding is None: continue
+        for c_comp_idx, c_node_id, c_sent_idx in claims:
+             if not (0 <= c_sent_idx < len(sentence_embeddings)): continue
+             claim_embedding = sentence_embeddings[c_sent_idx]
+             if claim_embedding is None: continue
+             similarity = calculate_similarity(premise_embedding, claim_embedding)
+             if similarity is not None and similarity >= LINKING_SIMILARITY_THRESHOLD: # Eşik kontrolü
+                  console.print(f"   -> Linking {p_node_id} to {c_node_id} (Similarity: {similarity:.2f})", style="dim")
+                  G.add_edge(p_node_id, c_node_id, relation="supports", similarity=similarity)
+                  edges_added += 1
+    if edges_added == 0:
+         console.print(f" -> Could not link any premises to claims based on similarity threshold ({LINKING_SIMILARITY_THRESHOLD}).", style="dim")
+    console.print(f" -> Built argument graph with {G.number_of_nodes()} nodes and {G.number_of_edges()} edges (Semantic Linking).", style="dim")
+    return G
+
+
+# Grafik Formatlama Fonksiyonu (Aynı)
+def format_graph_text(graph: nx.DiGraph | None) -> str:
+    # ... (Fonksiyonun içeriği öncekiyle aynı) ...
+    if graph is None: return "  Argument graph could not be built."
+    if graph.number_of_nodes() == 0: return "  No argument components identified to build a graph."
+    output_lines = ["  Argument Structure (Linked by Semantic Similarity):"]
+    isolated_nodes = [node for node, degree in graph.degree() if degree == 0 and graph.in_degree(node)==0 and graph.out_degree(node)==0 ]
+    connected_nodes = set()
+    if graph.number_of_edges() == 0:
+        if not isolated_nodes: output_lines.append("  No argument structure links could be determined.")
+    else:
+        output_lines.append("  Detected Links (Premise --Supports (Similarity)--> Claim):")
+        for u, v, data in graph.edges(data=True):
+            connected_nodes.add(u); connected_nodes.add(v)
+            u_data = graph.nodes[u]; v_data = graph.nodes[v]
+            u_shape = u_data.get('shape', '[]'); v_shape = v_data.get('shape', '()')
+            u_label = u_data.get('label', u); v_label = v_data.get('label', v)
+            similarity = data.get('similarity')
+            sim_str = f"(Sim: {similarity:.2f})" if similarity is not None else ""
+            output_lines.append(f"    {u_shape[0]}{u}{u_shape[1]}: {u_label}")
+            output_lines.append(f"      {' ' * len(u)} --Supports {sim_str}--> {v_shape[0]}{v}{v_shape[1]}: {v_label}")
+            output_lines.append("")
+
+    really_isolated = set(isolated_nodes) # Tüm izoleler
+    if really_isolated:
+         # Eğer kenar varsa ve izole düğüm varsa başlık ekle
+         if graph.number_of_edges() > 0:
+             output_lines.append("  Nodes without determined links:")
+         # Kenar yoksa zaten yukarıda başlık vardı
+         elif not isolated_nodes and graph.number_of_edges() == 0 : # Hata durumu, yukarıda handle edildi
+             pass
+         elif isolated_nodes and graph.number_of_edges() == 0: # Sadece izole düğümler varsa
+              output_lines.append("  Nodes (No links determined):")
+
+
+         for node_id in sorted(list(really_isolated)):
+              data = graph.nodes[node_id]
+              shape = data.get('shape', '??')
+              label = data.get('label', node_id)
+              output_lines.append(f"    {shape[0]}{node_id}{shape[1]}: {label}")
+
+    output_lines.append(f"  [dim](Links based on similarity >= {LINKING_SIMILARITY_THRESHOLD})[/dim]")
+    return "\n".join(output_lines)

cli.py

@@ -0,0 +1,187 @@
+# cli.py (V2/V3 - Adım 3.1: Anlamsal Görselleştirme Entegrasyonu)
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+from rich.padding import Padding
+import data_models
+import nlp_utils
+import argument_analyzer
+import logic_analyzer
+# import evidence_analyzer # Kaldırıldı
+import rhetoric_analyzer
+import synthesis_engine
+import argument_visualizer # Güncellenmiş versiyonu çağıracak
+import networkx as nx
+from typing import Optional, List
+import sys
+import textwrap
+
+console = Console()
+sentences = []
+
+# --- Yardımcı Raporlama Fonksiyonları (Aynı) ---
+def format_sentence_with_highlights(
+    sentence_idx: int, all_sentences: List[data_models.SentenceInfo],
+    findings: List[data_models.Finding], components: List[data_models.ArgumentComponent]
+) -> Text:
+    # ... (Fonksiyon içeriği öncekiyle aynı)...
+    if sentence_idx < 0 or sentence_idx >= len(all_sentences): return Text("(Error: Invalid sentence index)")
+    sentence = all_sentences[sentence_idx]; text = Text(sentence.text)
+    for comp in components:
+        if comp.sentence_index == sentence_idx:
+             style = "bold magenta" if comp.component_type == "Claim" else "magenta"
+             start = comp.span_start - sentence.start_char; end = comp.span_end - sentence.start_char
+             if 0 <= start < end <= len(sentence.text):
+                 try: text.stylize(style, start, end)
+                 except Exception as e: console.print(f"[dim yellow]Warn: Styling component ({start}-{end}) in sent {sentence_idx}: {e}[/dim]")
+    for finding in findings:
+         if finding.span_start == sentence.start_char and finding.span_end == sentence.end_char:
+              prefix = "[F] " if finding.finding_type == "Fallacy" else \
+                       "[R] " if finding.finding_type == "RhetoricalDevice" else "[?] "
+              style = "bold red" if prefix=="[F] " else "bold yellow" if prefix=="[R] " else ""
+              text.insert(0, prefix, style=style)
+    return text
+
+# Ana CLI Fonksiyonu
+def main(
+    text: Optional[str] = typer.Option(None, "--text", "-t", help="Text to analyze directly."),
+    file_path: Optional[str] = typer.Option(None, "--file", "-f", help="Path to a text file to analyze."),
+    max_findings_display: int = typer.Option(5, "--max-findings", "-m", help="Max number of each finding type to display in detail.")
+):
+    """
+    ETHOS: The AI Arbiter of Rational Discourse (CLI) - v2.2
+    Semantic Argument Linking & AI Fallacy Integration.
+    """
+    console.print(Panel("[bold cyan]ETHOS Analysis Engine v2.2 Starting...[/bold cyan]", expand=False, border_style="cyan"))
+    # --- Girdi Kontrolü ve Yükleme ---
+    if text and file_path: console.print("[bold red]Error: Use --text OR --file, not both.[/bold red]"); raise typer.Exit(code=1)
+    if not text and not file_path: console.print("[bold red]Error: Use --text '...' OR --file '...'[/bold red]"); raise typer.Exit(code=1)
+    text_to_analyze = ""; input_source_msg = ""
+    if file_path:
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f: text_to_analyze = f.read()
+            input_source_msg = f"File: [yellow]'{file_path}'[/yellow]"
+        except Exception as e: console.print(f"[bold red]Error reading file '{file_path}': {e}[/bold red]"); raise typer.Exit(code=1)
+    elif text:
+        text_to_analyze = text; input_source_msg = f"Input Text ({len(text_to_analyze)} chars)"
+    if not text_to_analyze.strip(): console.print("[bold red]Error: Input text is empty.[/bold red]"); raise typer.Exit(code=1)
+    console.print(Padding(f"Analyzing: {input_source_msg}", (0, 1)))
+
+    # --- Analiz Adımları ---
+    console.print("\n[bold blue]--- Initializing Analyzers & Embeddings ---[/bold blue]")
+    try:
+        nlp_utils.load_spacy_model(); nlp_utils.load_bert()
+        spacy_doc = nlp_utils.process_text_spacy(text_to_analyze)
+        # Tüm cümle embeddinglerini başta hesapla
+        sentence_embeddings = nlp_utils.get_all_sentence_embeddings(spacy_doc)
+    except Exception as e: console.print(f"[bold red]Error during model loading/processing/embedding: {e}[/bold red]"); raise typer.Exit(code=1)
+    if not spacy_doc: console.print("[bold red]Error: spaCy doc creation failed.[/bold red]"); raise typer.Exit(code=1)
+
+    # --- Analizleri Çalıştır ---
+    console.print("\n[bold blue]--- Running Analysis Modules ---[/bold blue]")
+    global sentences
+    sentences = [data_models.SentenceInfo(text=s.text, start_char=s.start_char, end_char=s.end_char, tokens=[t.text for t in s]) for s in spacy_doc.sents]
+
+    console.print("[cyan]Running Argument Analyzer (Enhanced)...[/cyan]")
+    argument_components = argument_analyzer.enhanced_component_analyzer(spacy_doc)
+
+    console.print("[cyan]Running Logic Analyzer (Enhanced - Rules + ML)...[/cyan]")
+    fallacy_findings = logic_analyzer.enhanced_fallacy_analyzer(spacy_doc)
+
+    evidence_findings = [] # Kanıt analizi kaldırıldı
+
+    console.print("[cyan]Running Rhetoric Analyzer...[/cyan]")
+    rhetoric_findings = rhetoric_analyzer.simple_rhetoric_analyzer(spacy_doc)
+
+    console.print("[cyan]Running Synthesis Engine (Evidence Excluded)...[/cyan]")
+    all_findings: List[data_models.Finding] = fallacy_findings + rhetoric_findings
+    analysis_summary = synthesis_engine.generate_summary_ratings(argument_components, all_findings)
+
+    # --- Argüman Grafiğini Oluştur (Embeddingler ile) ---
+    console.print("[cyan]Building Argument Graph (Semantic Linking)...[/cyan]")
+    # Görselleyiciye embedding listesini de gönder
+    argument_graph = argument_visualizer.build_argument_graph(argument_components, sentence_embeddings) # <-- DEĞİŞİKLİK BURADA
+    graph_text_representation = argument_visualizer.format_graph_text(argument_graph)
+
+    # --- Sonuç Nesnesini Oluştur ---
+    analysis_result = data_models.AnalyzedText(
+        original_text=text_to_analyze, sentences=sentences,
+        argument_components=argument_components, findings=all_findings,
+        analysis_summary=analysis_summary
+    )
+
+    # --- Raporlama ---
+    console.rule("[bold green]ETHOS Analysis Report[/bold green]", style="green")
+    # Bölüm 1: Özet (Aynı)
+    summary_table = Table(title="Analysis Summary", show_header=False, box=None, padding=(0, 1))
+    # ... (Özet tablo kodu aynı) ...
+    if analysis_result.analysis_summary:
+        for category, rating in analysis_result.analysis_summary.items():
+            style = "red" if rating.startswith(("Low", "Weak", "Questionable")) else "yellow" if rating.startswith(("Medium", "Moderate", "Mixed")) else "green"
+            if rating == "Not Evaluated": style = "dim"
+            summary_table.add_row(category, f"[{style}]{rating}[/{style}]")
+    else: summary_table.add_row("Summary", "[dim]Not generated.[/dim]")
+    console.print(Padding(summary_table, (1, 0)))
+
+
+    # Bölüm 2: Tespit Edilen Bulgular (Aynı)
+    console.print("\n[bold underline]Detected Findings:[/bold underline]")
+    if not analysis_result.findings: console.print(Padding("  No significant findings detected.", (0, 2)))
+    else:
+        # ... (Bulgu gruplama ve yazdırma kodu aynı) ...
+        grouped_findings = {};
+        for f in analysis_result.findings: grouped_findings.setdefault(f.finding_type, []).append(f)
+        grouped_findings.pop("EvidenceIndicator", None); grouped_findings.pop("EvidenceStatus", None)
+        if not grouped_findings: console.print(Padding("  No significant findings detected.", (0, 2)))
+        else:
+            for f_type, findings_list in grouped_findings.items():
+                 color = "red" if f_type=="Fallacy" else "yellow" if f_type=="RhetoricalDevice" else "white"
+                 console.print(Padding(f"[bold {color}]{f_type} Indicators ({len(findings_list)} found):[/bold {color}]", (1, 1)))
+                 for i, finding in enumerate(findings_list[:max_findings_display]):
+                     details_dict = finding.details if finding.details else {}
+                     details_text = details_dict.get('fallacy_type') or details_dict.get('device_type') or 'Details N/A'
+                     trigger_text = details_dict.get('trigger') or details_dict.get('words')
+                     confidence = details_dict.get('confidence'); model_used = details_dict.get('model_used')
+                     details_str = f"({details_text}"
+                     if trigger_text and not model_used: details_str += f", Trigger: '{textwrap.shorten(str(trigger_text), width=25, placeholder='...')}'"
+                     if confidence is not None: details_str += f", Score: {confidence:.2f}"
+                     if model_used: details_str += f", Model: '{model_used.split('/')[-1]}'"
+                     details_str += ")"
+                     console.print(Padding(f"{i+1}. {finding.description} {details_str}", (0, 3)))
+                     try:
+                          sentence_idx = next(idx for idx, s in enumerate(analysis_result.sentences) if s.start_char == finding.span_start)
+                          related_sentence_text = analysis_result.sentences[sentence_idx].text
+                          console.print(Padding(f"[dim]   In Sent {sentence_idx+1}: \"{textwrap.shorten(related_sentence_text, width=90, placeholder='...')}\"[/dim]", (0, 5)))
+                     except StopIteration: console.print(Padding(f"[dim]   (Could not pinpoint exact sentence for span starting at char {finding.span_start})[/dim]", (0,5)))
+                 if len(findings_list) > max_findings_display: console.print(Padding(f"... and {len(findings_list) - max_findings_display} more.", (0, 3)))
+
+
+    # Bölüm 3: Argüman Bileşenleri (Aynı)
+    console.print("\n[bold underline]Identified Argument Components:[/bold underline]")
+    if not analysis_result.argument_components: console.print(Padding("  No argument components identified.", (0, 2)))
+    else:
+        # ... (Bileşen tablosu kodu aynı) ...
+        comp_table = Table(title=None, show_header=True, header_style="bold magenta", box=None, padding=(0,1))
+        comp_table.add_column("Type", style="magenta", width=10); comp_table.add_column("Text Snippet (Confidence)")
+        for comp in analysis_result.argument_components:
+             conf_str = f"({comp.confidence:.2f})" if comp.confidence is not None else ""
+             comp_table.add_row(comp.component_type, f"\"{textwrap.shorten(comp.text, width=90, placeholder='...')}\" {conf_str}")
+        console.print(Padding(comp_table, (1, 1)))
+
+
+    # Bölüm 4: Argüman Yapısı Görselleştirmesi (Güncellenmiş formatı yazdıracak)
+    console.print("\n[bold underline]Argument Structure Visualization (Semantic):[/bold underline]") # Başlık güncellendi
+    console.print(Padding(graph_text_representation, (0, 1))) # <-- GRAFİĞİ YAZDIR
+    # Not metni güncellendi
+    console.print(Padding(f"[dim](Note: Links based on semantic similarity >= {argument_visualizer.LINKING_SIMILARITY_THRESHOLD})[/dim]", (0,1)))
+
+
+    console.rule(style="green")
+    console.print(f"(V2 Semantic Argument Linking. Total potential findings: {len(analysis_result.findings)})") # Mesaj güncellendi
+
+
+# Script doğrudan çalıştırıldığında typer.run ile main fonksiyonunu çağır
+if __name__ == "__main__":
+    typer.run(main)

data_models.py

@@ -0,0 +1,41 @@
+# data_models.py
+from typing import List, Optional, Any
+from pydantic import BaseModel, Field
+
+class Finding(BaseModel):
+    """Analiz sırasında bulunan genel bir bulguyu temsil eder."""
+    finding_type: str = Field(..., description="Bulgunun türü (örn. 'Fallacy', 'RhetoricalDevice', 'EvidenceStatus')")
+    description: str = Field(..., description="Bulgunun kısa açıklaması")
+    severity: Optional[str] = Field(None, description="Bulgunun ciddiyeti (örn. 'Low', 'Medium', 'High')")
+    span_start: Optional[int] = Field(None, description="Bulgunun metindeki başlangıç karakter indeksi")
+    span_end: Optional[int] = Field(None, description="Bulgunun metindeki bitiş karakter indeksi")
+    details: Optional[dict[str, Any]] = Field(None, description="Bulguya özel ek detaylar")
+
+class ArgumentComponent(BaseModel):
+    """Tespit edilen bir argüman bileşenini temsil eder (İddia, Gerekçe vb.)."""
+    component_type: str = Field(..., description="Bileşenin türü (örn. 'Claim', 'Premise')")
+    text: str = Field(..., description="Bileşenin tam metni")
+    sentence_index: int = Field(..., description="Bileşenin bulunduğu cümlenin indeksi")
+    span_start: int = Field(..., description="Bileşenin cümle içindeki başlangıç karakter indeksi")
+    span_end: int = Field(..., description="Bileşenin cümle içindeki bitiş karakter indeksi")
+    confidence: Optional[float] = Field(None, description="Tespitin güven skoru (0.0 - 1.0)")
+
+class SentenceInfo(BaseModel):
+    """Tek bir cümle hakkındaki bilgileri içerir."""
+    text: str
+    start_char: int
+    end_char: int
+    tokens: List[str] # Şimdilik basitçe token metinleri
+
+class AnalyzedText(BaseModel):
+    """Tüm analiz sürecinin sonucunu içeren ana model."""
+    original_text: str
+    processed_text: Optional[str] = None
+    language: str = "en"
+    sentences: List[SentenceInfo] = []
+    findings: List[Finding] = [] # Tüm bulgular burada toplanacak
+    argument_components: List[ArgumentComponent] = []
+    analysis_summary: Optional[dict[str, str]] = Field(None, description="Analizin özet değerlendirmesi") # YENİ ALAN
+
+    class Config:
+        extra = 'forbid'

evidence_analyzer.py

@@ -0,0 +1,93 @@
+# evidence_analyzer.py (V2 - Adım 2.4 Revizyonu: Basitleştirilmiş : GEREKLİYDİ ZAYN BAŞARAMADI :))
+import spacy
+from spacy.tokens import Doc, Span
+from typing import List, Tuple
+import data_models
+# Artık nlp_utils, torch, F'e gerek yok bu basit versiyonda
+from rich.console import Console
+import re
+
+console = Console()
+
+# Sabitler (Aynı)
+CITATION_PHRASES = {
+    "according to", "study shows", "research indicates", "data suggests",
+    "experts say", "report finds", "source:", "evidence shows", "demonstrates that",
+    "reported by", "stated by", "cited in"
+}
+URL_REGEX = r"(?:https?://|www\.)[^\s/$.?#].[^\s]*"
+
+# Yardımcı Fonksiyon (Aynı)
+def has_potential_evidence_indicator(sent: Span) -> Tuple[bool, str, str]:
+    sent_text = sent.text; sent_text_lower = sent.text.lower()
+    if not sent_text.strip(): return False, "", ""
+    urls = re.findall(URL_REGEX, sent_text)
+    if urls: return True, "URL", urls[0]
+    if re.search(r"\b\d{3,}\b", sent_text) or '%' in sent_text or re.search(r"\b\d+(?:\.\d+)?\b", sent_text):
+        match = re.search(r"\b\d+(?:\.\d+)?%?\b", sent_text)
+        trigger_text = match.group(0) if match else "Number/Percentage"
+        return True, "Numerical Data", trigger_text
+    for phrase in CITATION_PHRASES:
+        if f" {phrase} " in f" {sent_text_lower} " or sent_text_lower.startswith(f"{phrase} "):
+            return True, "Citation Phrase", phrase
+    return False, "", ""
+
+# Ana Analiz Fonksiyonu (Basitleştirilmiş - Sadece aynı cümleyi kontrol eder)
+def simplified_evidence_analyzer(
+    doc: Doc,
+    argument_components: List[data_models.ArgumentComponent]
+    # sentence_embeddings parametresi kaldırıldı
+) -> List[data_models.Finding]:
+    """
+    Tespit edilen iddiaları (Claim) inceler ve SADECE kendi cümlelerinde
+    basit kanıt göstergeleri olup olmadığını kontrol eder (V1 Tarzı Basit).
+    """
+    findings = []
+    claims_data = [(idx, comp) for idx, comp in enumerate(argument_components) if comp.component_type == "Claim"]
+    sentences = list(doc.sents)
+    num_sentences = len(sentences)
+
+    if not claims_data:
+        console.print(" -> No claims found to analyze for evidence.", style="dim"); return findings
+
+    console.print(f" -> Analyzing {len(claims_data)} claims for evidence indicators (Simplified: Same sentence only)...", style="dim")
+
+    for claim_comp_idx, claim in claims_data:
+        claim_sentence_idx = claim.sentence_index
+        claim_text_snippet = claim.text[:100] + "..."
+
+        if not (0 <= claim_sentence_idx < num_sentences):
+            console.print(f"[yellow]Warn: Invalid sentence index {claim_sentence_idx} for claim comp_idx {claim_comp_idx}, skipping.[/yellow]"); continue
+
+        claim_sentence_span = sentences[claim_sentence_idx]
+
+        # Sadece iddianın kendi cümlesini kontrol et
+        has_indicator, indicator_type, indicator_text = has_potential_evidence_indicator(claim_sentence_span)
+
+        if has_indicator:
+            # Gösterge varsa EvidenceIndicator ekle
+            findings.append(data_models.Finding(
+                finding_type="EvidenceIndicator",
+                description=f"Potential evidence indicator ('{indicator_type}') found in the same sentence as the claim.",
+                severity="Info",
+                span_start=claim_sentence_span.start_char,
+                span_end=claim_sentence_span.end_char,
+                details={
+                    "indicator_type": indicator_type, "indicator_trigger": indicator_text,
+                    "location": "same_sentence", "linked_claim_index": claim_comp_idx,
+                    "claim_text": claim_text_snippet
+                }
+            ))
+        else:
+            # Gösterge yoksa EvidenceStatus ekle
+            findings.append(data_models.Finding(
+                finding_type="EvidenceStatus",
+                description="Claim lacks explicit evidence indicator in the same sentence.", # Açıklama basitleşti
+                severity="Medium",
+                span_start=claim_sentence_span.start_char, # İddia cümlesinin span'ı
+                span_end=claim_sentence_span.end_char,
+                details={"claim_text": claim_text_snippet}
+            ))
+
+    console.print(f" -> Simplified Evidence Analyzer generated {len(findings)} findings.", style="dim")
+    return findings

logic_analyzer.py

@@ -0,0 +1,131 @@
+# logic_analyzer.py (V2 - Adım 2.4 Düzeltmesi - Fonksiyon Adı Hatası Giderildi)
+import spacy
+from spacy.tokens import Doc, Span
+from typing import List, Dict, Tuple
+import data_models # Düz yapı importu
+import nlp_utils   # Embedding fonksiyonları için
+import torch
+import torch.nn as nn
+from rich.console import Console
+
+console = Console()
+
+# --- Basit Kural Tabanlı Safsata İpuçları (Aynı) ---
+POPULUM_INDICATORS = {
+    "everybody knows", "everyone knows", "everyone agrees",
+    "it is common sense", "most people think", "the majority believes"
+}
+HASTY_GENERALIZATION_KEYWORDS = {"always", "never", "all", "none", "every", "everyone", "nobody"}
+def check_false_dichotomy(sent_text_lower: str) -> bool:
+    has_either = " either " in f" {sent_text_lower} " or sent_text_lower.startswith("either ")
+    has_or = " or " in f" {sent_text_lower} "
+    return has_either and has_or
+
+# Kural Tabanlı Tespit Fonksiyonları (Aynı)
+def detect_ad_populum(sent: Span) -> List[data_models.Finding]:
+    findings = []; sent_text_lower = sent.text.lower()
+    for indicator in POPULUM_INDICATORS:
+        if indicator in sent_text_lower:
+            findings.append(data_models.Finding(finding_type="Fallacy", description="Potential 'Appeal to Popularity' (Ad Populum / Bandwagon) detected by rule.", severity="Medium", span_start=sent.start_char, span_end=sent.end_char, details={"fallacy_type": "Ad Populum (Rule)", "trigger": indicator})); break
+    return findings
+
+def detect_hasty_generalization(sent: Span) -> List[data_models.Finding]:
+    findings = []
+    for token in sent:
+        if token.text.lower() in HASTY_GENERALIZATION_KEYWORDS:
+            findings.append(data_models.Finding(finding_type="Fallacy", description="Potential 'Hasty Generalization' detected by keyword rule (needs context!).", severity="Low", span_start=sent.start_char, span_end=sent.end_char, details={"fallacy_type": "Hasty Generalization (Rule)", "trigger": token.text})); break
+    return findings
+
+def detect_false_dichotomy(sent: Span) -> List[data_models.Finding]:
+    findings = []; sent_text_lower = sent.text.lower()
+    if check_false_dichotomy(sent_text_lower):
+        findings.append(data_models.Finding(finding_type="Fallacy", description="Potential 'False Dichotomy' (Either/Or Fallacy) detected by rule.", severity="Medium", span_start=sent.start_char, span_end=sent.end_char, details={"fallacy_type": "False Dichotomy (Rule)", "trigger": "either...or pattern"}))
+    return findings
+
+# --- ML Tabanlı Safsata Tespiti (Placeholder - Fonksiyon adı düzeltildi) ---
+FALLACY_CLASSES = ["Ad Hominem", "Hasty Generalization", "Appeal to Popularity", "No Fallacy"]
+BERT_HIDDEN_SIZE = 768; NUM_FALLACY_CLASSES = len(FALLACY_CLASSES)
+
+class FallacyClassifierPlaceholder(nn.Module):
+    def __init__(self, input_size=BERT_HIDDEN_SIZE, num_classes=NUM_FALLACY_CLASSES):
+        super().__init__(); self.linear = nn.Linear(input_size, num_classes)
+        # Bu mesajın sadece bir kere görünmesi için kontrol eklenebilir ama şimdilik kalsın
+        console.print("[yellow]Placeholder Fallacy Classifier initialized (UNTRAINED). Results will NOT be accurate.[/yellow]", style="dim")
+    def forward(self, sentence_embedding):
+        if sentence_embedding.dim() == 1: sentence_embedding = sentence_embedding.unsqueeze(0)
+        logits = self.linear(sentence_embedding); return logits
+
+try:
+    placeholder_classifier = FallacyClassifierPlaceholder()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    placeholder_classifier.to(device); placeholder_classifier.eval()
+    _ml_classifier_loaded = True
+except Exception as e:
+    console.print(f"[bold red]Error initializing ML Fallacy Classifier: {e}. ML detection disabled.[/bold red]")
+    _ml_classifier_loaded = False
+
+
+def ml_fallacy_detection_for_sentence(sentence_text: str, sent_span: Span) -> List[data_models.Finding]: # Span eklendi
+    """
+    Tek bir cümle için BERT embedding'i alır ve EĞİTİLMEMİŞ sınıflandırıcı ile
+    safsata tahmini yapar (PLACEHOLDER - DOĞRU SONUÇ VERMEZ).
+    Span bilgisi eklendi.
+    """
+    findings = []
+    if not _ml_classifier_loaded: return findings # Sınıflandırıcı yüklenemediyse boş dön
+
+    try:
+        # DÜZELTME: Doğru fonksiyon adını kullan: get_sentence_embedding (tekil)
+        sentence_embedding = nlp_utils.get_sentence_embedding(sentence_text, strategy='mean')
+        if sentence_embedding is None: # Embedding alınamadıysa
+             return findings
+
+        sentence_embedding = sentence_embedding.to(device)
+
+        with torch.no_grad(): logits = placeholder_classifier(sentence_embedding)
+
+        probabilities = torch.softmax(logits.squeeze(), dim=0)
+        predicted_prob, predicted_idx = torch.max(probabilities, dim=0)
+        predicted_class = FALLACY_CLASSES[predicted_idx.item()]
+        predicted_prob = predicted_prob.item()
+
+        # Sadece "No Fallacy" olmayanları ekle (güvenilmez skorla)
+        if predicted_class != "No Fallacy":
+            findings.append(data_models.Finding(
+                finding_type="Fallacy",
+                description=f"Potential '{predicted_class}' detected by ML Placeholder (Score: {predicted_prob:.2f} - UNRELIABLE).",
+                severity="Low",
+                span_start=sent_span.start_char, # Doğru span bilgisi kullanıldı
+                span_end=sent_span.end_char,     # Doğru span bilgisi kullanıldı
+                details={"fallacy_type": f"{predicted_class} (ML Placeholder)", "confidence": predicted_prob}
+            ))
+    except Exception as e:
+        console.print(f"[yellow]Warning: ML Fallacy prediction failed for sentence: {e}[/yellow]", style="dim")
+    return findings
+
+
+# --- Geliştirilmiş Ana Analiz Fonksiyonu (Düzeltilmiş Hali) ---
+def enhanced_fallacy_analyzer(doc: Doc) -> List[data_models.Finding]:
+    """
+    Metindeki cümleleri hem basit kurallarla hem de ML Placeholder ile
+    analiz ederek potansiyel safsataları bulur (V2 Seviyesi).
+    """
+    all_findings = []
+    console.print(" -> Running Rule-Based Fallacy Checks...", style="dim")
+    sentences = list(doc.sents)
+    for sent in sentences:
+        all_findings.extend(detect_ad_populum(sent))
+        all_findings.extend(detect_hasty_generalization(sent))
+        all_findings.extend(detect_false_dichotomy(sent))
+
+    if _ml_classifier_loaded: # ML sınıflandırıcı yüklendiyse çalıştır
+        console.print(f" -> Running ML Placeholder Fallacy Checks ({len(sentences)} sentences)...", style="dim")
+        for sent in sentences:
+            # ml_fallacy_detection_for_sentence'a artık span'ı da gönderiyoruz
+            all_findings.extend(ml_fallacy_detection_for_sentence(sent.text, sent))
+    else:
+         console.print(" -> Skipping ML Placeholder Fallacy Checks (Initialization failed).", style="dim")
+
+    # TODO: Bulguları birleştirme / önceliklendirme
+    console.print(f" -> Enhanced Fallacy Analyzer found {len(all_findings)} potential indicators (Rules + ML Placeholder).", style="dim")
+    return all_findings

nlp_utils.py

@@ -0,0 +1,109 @@
+# nlp_utils.py (V2 - Adım 2.4 Eklentisi)
+import spacy
+from spacy.tokens import Doc, Span # Span eklendi
+from transformers import AutoTokenizer, AutoModel
+import torch
+import torch.nn.functional as F # Cosine Similarity için eklendi
+from rich.console import Console
+from typing import List, Tuple # List, Tuple eklendi
+import os
+
+# os.environ['HF_HUB_DISABLE_SYMLINKS_WARNING'] = '1'
+
+console = Console()
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+console.print(f"Using device: [bold {'green' if device.type == 'cuda' else 'yellow'}]{device}[/bold {'green' if device.type == 'cuda' else 'yellow'}]")
+if device.type == 'cuda': console.print(f"CUDA Device Name: {torch.cuda.get_device_name(0)}")
+
+# --- spaCy ---
+SPACY_MODEL_NAME = "en_core_web_lg"
+_nlp = None
+
+def load_spacy_model(model_name: str = SPACY_MODEL_NAME) -> spacy.language.Language:
+    global _nlp
+    if _nlp is None:
+        try:
+            console.print(f"Loading spaCy model '{model_name}'...")
+            _nlp = spacy.load(model_name)
+            console.print(f"[green]spaCy model '{model_name}' loaded successfully (on CPU).[/green]")
+        except OSError:
+            console.print(f"[bold red]Error: spaCy model '{model_name}' not found.[/bold red]"); raise
+    return _nlp
+
+def process_text_spacy(text: str) -> spacy.tokens.Doc:
+    spacy_nlp = load_spacy_model()
+    if spacy_nlp: return spacy_nlp(text)
+    raise RuntimeError("spaCy model could not be loaded or process failed.")
+
+# --- Transformers (BERT) ---
+BERT_MODEL_NAME = "bert-base-uncased"
+_tokenizer = None
+_bert_model = None
+
+def load_bert(model_name: str = BERT_MODEL_NAME) -> tuple[AutoTokenizer, AutoModel]:
+    global _tokenizer, _bert_model
+    if _tokenizer is None:
+        try:
+            console.print(f"Loading BERT tokenizer for '{model_name}'...")
+            _tokenizer = AutoTokenizer.from_pretrained(model_name)
+            console.print(f"[green]BERT Tokenizer for '{model_name}' loaded successfully.[/green]")
+        except Exception as e: console.print(f"[bold red]Error loading BERT tokenizer '{model_name}': {e}[/bold red]"); raise
+    if _bert_model is None:
+        try:
+            console.print(f"Loading full BERT model '{model_name}'...")
+            _bert_model = AutoModel.from_pretrained(model_name)
+            _bert_model.to(device); _bert_model.eval()
+            console.print(f"[green]Full BERT Model '{model_name}' loaded successfully to [bold]{device}[/bold].[/green]")
+        except Exception as e: console.print(f"[bold red]Error loading full BERT model '{model_name}': {e}[/bold red]"); raise
+    return _tokenizer, _bert_model
+
+def get_bert_embeddings(text: str, max_length: int = 512) -> tuple[torch.Tensor, torch.Tensor]:
+    try: tokenizer, model = load_bert()
+    except Exception as e: raise RuntimeError(f"Failed to load BERT model or tokenizer: {e}")
+    inputs = tokenizer(text, return_tensors="pt", max_length=max_length, padding=True, truncation=True)
+    inputs_on_device = {k: v.to(device) for k, v in inputs.items()}
+    with torch.no_grad():
+        try: outputs = model(**inputs_on_device)
+        except Exception as e: console.print(f"[bold red]Error during BERT inference: {e}[/bold red]"); raise RuntimeError(f"BERT inference failed: {e}")
+    last_hidden_state = outputs.last_hidden_state; pooler_output = outputs.pooler_output
+    return last_hidden_state.cpu().detach(), pooler_output.cpu().detach()
+
+def get_sentence_embedding(sentence_text: str, strategy: str = 'mean', max_length: int = 512) -> torch.Tensor:
+    """ Tek bir cümlenin embedding'ini hesaplar. """
+    # Not: Bu hala her cümle için ayrı ayrı model çağrısı yapar, verimli değil.
+    # Daha iyisi: Tüm metni bir kerede işleyip, sonra cümle spanlarına göre ortalama almak.
+    # Şimdilik bu basit versiyonla devam edelim.
+    try:
+        last_hidden_state, _ = get_bert_embeddings(sentence_text, max_length)
+        if strategy == 'cls':
+            return last_hidden_state[0, 0, :]
+        elif strategy == 'mean':
+            tokenizer, _ = load_bert()
+            inputs = tokenizer(sentence_text, return_tensors="pt", max_length=max_length, padding=True, truncation=True)
+            attention_mask = inputs['attention_mask'].cpu()
+            input_mask_expanded = attention_mask.unsqueeze(-1).expand(last_hidden_state.size()).float()
+            sum_embeddings = torch.sum(last_hidden_state * input_mask_expanded, 1)
+            sum_mask = torch.clamp(input_mask_expanded.sum(1), min=1e-9)
+            mean_embeddings = sum_embeddings / sum_mask
+            return mean_embeddings[0]
+        else:
+            raise ValueError(f"Unknown strategy: {strategy}")
+    except Exception as e:
+        console.print(f"[yellow]Warning: Failed to get embedding for sentence '{sentence_text[:50]}...': {e}[/yellow]")
+        # Hata durumunda sıfır vektörü döndürelim? Veya None? None daha iyi.
+        return None
+
+
+# --- YENİ FONKSİYON ---
+def get_all_sentence_embeddings(doc: Doc, strategy: str = 'mean', max_length: int = 512) -> List[torch.Tensor | None]:
+    """
+    Bir spaCy Doc içerisindeki tüm cümlelerin BERT embedding'lerini hesaplar.
+    (Mevcut haliyle her cümle için ayrı model çağrısı yapar - verimsiz)
+    """
+    console.print(f" -> Calculating BERT sentence embeddings for {len(list(doc.sents))} sentences (Strategy: {strategy})...", style="dim")
+    embeddings = []
+    for sent in doc.sents:
+        embedding = get_sentence_embedding(sent.text, strategy=strategy, max_length=max_length)
+        embeddings.append(embedding)
+    console.print(f" -> Sentence embeddings calculation complete.", style="dim")
+    return embeddings

requirements.txt

@@ -0,0 +1,26 @@
+# requirements.txt
+
+# Temel NLP ve Model Altyapısı
+spacy>=3.7.0,<4.0.0
+transformers[torch]>=4.30.0,<5.0.0  # PyTorch tabanlı transformers
+torch>=2.0.0,<3.0.0              # Veya sisteminize uygun PyTorch sürümü
+numpy<2.0                        # ÖNEMLİ: NumPy 2.x ile uyumsuzlukları önlemek için
+
+# Veri Modelleme ve Doğrulama
+pydantic>=2.0.0,<3.0.0
+
+# Komut Satırı Arayüzü ve Güzel Çıktı
+typer[all]>=0.9.0,<0.13.0        # 'all' ile rich gibi ekstraları da kurar
+rich>=13.0.0,<14.0.0
+
+# Retorik Analiz için Duygu Analizi
+vaderSentiment>=3.3.0,<4.0.0
+
+# Argüman Görselleştirme için Grafik Kütüphanesi
+networkx>=3.0,<4.0
+
+# İleride gerekebilecekler (kurulu olabilir veya olmayabilir)
+# scikit-learn>=1.2.0,<1.5.0
+
+# Dil modeli (spaCy için ayrıca indirilecek - komut: python -m spacy download en_core_web_lg)
+# Bert modeli (transformers cache'i ile otomatik indirilecek)

rhetoric_analyzer.py

@@ -0,0 +1,102 @@
+# rhetoric_analyzer.py
+import spacy
+from spacy.tokens import Doc, Span, Token
+from typing import List
+import data_models # Düz yapı importu
+from rich.console import Console
+# VADER'ı import et
+from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
+
+console = Console()
+# VADER duygu analizcisini başlat
+analyzer = SentimentIntensityAnalyzer()
+
+# Basit Retorik İpuçları
+
+# Güçlü Duygu Eşiği (VADER compound score için)
+# -1 (çok negatif) ile +1 (çok pozitif) arasında.
+# |score| > 0.5 genellikle belirgin bir duygu ifade eder.
+STRONG_SENTIMENT_THRESHOLD = 0.5
+
+# Superlative'ler (En üstünlük belirten sıfatlar/zarflar)
+# spaCy'nin POS tag'lerini kullanabiliriz: 'JJS' (superlative adjective), 'RBS' (superlative adverb)
+SUPERLATIVE_TAGS = {"JJS", "RBS"}
+
+# Retorik Sorular (Basit: Soru işareti var mı?)
+# Daha gelişmiş analiz gerekir ama başlangıç için bu yeterli.
+
+def analyze_sentence_sentiment(sent: Span) -> List[data_models.Finding]:
+    """VADER kullanarak cümlenin duygu skorunu analiz eder ve güçlü duyguları bulur."""
+    findings = []
+    # VADER'ın polarity_scores fonksiyonu bir dict döndürür: {'neg', 'neu', 'pos', 'compound'}
+    vs = analyzer.polarity_scores(sent.text)
+    compound_score = vs['compound']
+
+    description = None
+    severity = "Low" # Varsayılan
+
+    if compound_score >= STRONG_SENTIMENT_THRESHOLD:
+        description = f"Sentence potentially expresses strong positive sentiment (VADER score: {compound_score:.2f})."
+        severity = "Medium"
+    elif compound_score <= -STRONG_SENTIMENT_THRESHOLD:
+        description = f"Sentence potentially expresses strong negative sentiment (VADER score: {compound_score:.2f})."
+        severity = "Medium"
+
+    if description:
+        findings.append(data_models.Finding(
+            finding_type="RhetoricalDevice",
+            description=description,
+            severity=severity,
+            span_start=sent.start_char,
+            span_end=sent.end_char,
+            details={"device_type": "Strong Sentiment", "vader_score": vs}
+        ))
+    return findings
+
+def detect_superlatives(sent: Span) -> List[data_models.Finding]:
+    """Cümlede superlative (en üstünlük) ifadeleri arar."""
+    findings = []
+    superlative_words = []
+    for token in sent:
+        if token.tag_ in SUPERLATIVE_TAGS:
+            superlative_words.append(token.text)
+
+    if superlative_words:
+        findings.append(data_models.Finding(
+            finding_type="RhetoricalDevice",
+            description=f"Use of superlative(s) detected: {', '.join(superlative_words)}.",
+            severity="Low", # Tek başına zayıf bir gösterge
+            span_start=sent.start_char,
+            span_end=sent.end_char,
+            details={"device_type": "Superlative", "words": superlative_words}
+        ))
+    return findings
+
+def detect_rhetorical_questions(sent: Span) -> List[data_models.Finding]:
+    """Cümlede soru işareti olup olmadığını kontrol eder (çok basit)."""
+    findings = []
+    if sent.text.strip().endswith("?"):
+        findings.append(data_models.Finding(
+            finding_type="RhetoricalDevice",
+            description="Sentence ends with a question mark (potential rhetorical question).",
+            severity="Low", # Bağlam olmadan bilmek zor
+            span_start=sent.start_char,
+            span_end=sent.end_char,
+            details={"device_type": "Potential Question"}
+        ))
+    return findings
+
+def simple_rhetoric_analyzer(doc: Doc) -> List[data_models.Finding]:
+    """
+    Metindeki cümleleri basit kurallarla analiz ederek potansiyel retorik araçları bulur.
+    """
+    all_findings = []
+    for sent in doc.sents:
+        # Her cümle için retorik kontrollerini çalıştır
+        all_findings.extend(analyze_sentence_sentiment(sent))
+        all_findings.extend(detect_superlatives(sent))
+        all_findings.extend(detect_rhetorical_questions(sent))
+        # Buraya diğer retorik fonksiyon çağrıları eklenebilir
+
+    console.print(f" -> Simple Rhetoric Analyzer found {len(all_findings)} potential rhetorical indicators.", style="dim")
+    return all_findings

synthesis_engine.py

@@ -0,0 +1,63 @@
+# synthesis_engine.py (V2 - Adım 2.4 Revizyonu: Kanıt Değerlendirmesi Kaldırıldı)
+from typing import List, Dict, Tuple
+import data_models
+from rich.console import Console
+
+console = Console()
+
+# Eşik Değerleri (Kanıt kaldırıldı)
+FALLACY_THRESHOLD_LOW = 1
+FALLACY_THRESHOLD_MEDIUM = 0
+# EVIDENCE_LACK_THRESHOLD_WEAK = 0.5 # Kaldırıldı
+# EVIDENCE_LACK_THRESHOLD_MODERATE = 0.1 # Kaldırıldı
+RHETORIC_THRESHOLD_HIGH = 5
+RHETORIC_THRESHOLD_MEDIUM = 2
+
+def generate_summary_ratings(
+    components: List[data_models.ArgumentComponent],
+    findings: List[data_models.Finding]
+) -> Dict[str, str]:
+    """
+    Bulunan bileşenlere ve bulgulara göre basit özet değerlendirmeler üretir.
+    (Kanıt değerlendirmesi kaldırıldı).
+    """
+    summary = {}
+
+    # --- Mantıksal Sağlamlık ---
+    fallacies = [f for f in findings if f.finding_type == "Fallacy"]
+    num_fallacies = len(fallacies)
+    # TODO: ML modelinden gelen güven skorları da değerlendirmeye katılabilir
+    if num_fallacies >= FALLACY_THRESHOLD_LOW:
+        summary["Logical Soundness"] = "Low (Potential fallacies detected)"
+    elif num_fallacies == FALLACY_THRESHOLD_MEDIUM:
+        summary["Logical Soundness"] = "Medium (No obvious fallacies detected by current rules/model)"
+    else: # Bu durum ML placeholder'da zor ama teorik olarak
+         summary["Logical Soundness"] = "High (Potentially sound)"
+
+
+    # --- Kanıtsal Dayanak ---
+    # BU BÖLÜM KALDIRILDI - Güvenilir analiz yapılamadığı için yorumda bırakıldı veya silindi.
+    # claims = [c for c in components if c.component_type == "Claim"]
+    # num_claims = len(claims)
+    # claims_lacking_evidence = sum(1 for f in findings if f.finding_type == "EvidenceStatus")
+    # if num_claims == 0:
+    #     summary["Evidential Basis"] = "N/A (No claims identified)"
+    # elif claims_lacking_evidence == num_claims:
+    #      summary["Evidential Basis"] = "Weak (All identified claims lack evidence indicators)"
+    # # ... (diğer eski kontroller) ...
+    summary["Evidential Basis"] = "Not Evaluated" # Geçici olarak devre dışı bırakıldı
+
+
+    # --- Retorik Bütünlük ---
+    rhetorical_findings = [f for f in findings if f.finding_type == "RhetoricalDevice"]
+    num_rhetoric = len(rhetorical_findings)
+    if num_rhetoric >= RHETORIC_THRESHOLD_HIGH:
+        summary["Rhetorical Clarity"] = "Questionable (High use of rhetorical devices detected)"
+    elif num_rhetoric >= RHETORIC_THRESHOLD_MEDIUM:
+        summary["Rhetorical Clarity"] = "Mixed (Some rhetorical devices detected)"
+    else:
+        summary["Rhetorical Clarity"] = "Appears Clear (Few rhetorical devices detected)"
+
+
+    console.print(f" -> Synthesis engine generated summary ratings (Evidence analysis excluded).", style="dim")
+    return summary