odab-note 0.1.0__py3-none-any.whl

odab_note/__init__.py

@@ -0,0 +1 @@
+# odab-note package

odab_note/cli.py

@@ -0,0 +1,193 @@
+import click
+from odab_note.database import OdabNoteDB
+from odab_note.server import mcp
+
+db = OdabNoteDB()
+
+@click.group()
+def main():
+    """OdabNote CLI - Manage wrong-answer notes (오답노트) for AI Agents."""
+    pass
+
+@main.command()
+def list():
+    """List all wrong-answer notes."""
+    notes = db.list_all_notes()
+    if not notes:
+        click.echo("No wrong-answer notes found.")
+        return
+
+    click.echo(f"{'ID':<4} | {'Keyword':<15} | {'Model':<15} | {'Count':<5} | {'Verified':<8} | {'Error Pattern'}")
+    click.echo("-" * 95)
+    for n in notes:
+        verified = "Yes" if n['is_verified'] else "No"
+        model = n.get('target_model', 'all')
+        # 에러 패턴은 첫 줄만 요약해서 보여줌
+        err_summary = n['error_pattern'].split('\n')[0]
+        if len(err_summary) > 40:
+            err_summary = err_summary[:37] + "..."
+        click.echo(f"{n['id']:<4} | {n['keyword']:<15} | {model:<15} | {n['occurrence_count']:<5} | {verified:<8} | {err_summary}")
+
+@main.command()
+@click.argument('note_id', type=int)
+def show(note_id):
+    """Show details of a specific wrong-answer note."""
+    notes = db.list_all_notes()
+    note = next((n for n in notes if n['id'] == note_id), None)
+    if not note:
+        click.echo(f"Note with ID {note_id} not found.")
+        return
+
+    verified = "Yes" if note['is_verified'] else "No"
+    click.echo(f"ID: {note['id']}")
+    click.echo(f"Keyword: {note['keyword']}")
+    click.echo(f"Occurrence Count: {note['occurrence_count']}")
+    click.echo(f"Verified (Veto Passed): {verified}")
+    click.echo("-" * 40)
+    click.echo(f"Error Pattern:\n{note['error_pattern']}")
+    click.echo("-" * 40)
+    click.echo(f"Correct Solution:\n{note['solution']}")
+
+@main.command()
+@click.option('--keyword', '-k', required=True, help="Target keyword or file name.")
+@click.option('--error', '-e', required=True, help="Error or mistake pattern.")
+@click.option('--fix', '-f', required=True, help="Correct action or fix pattern.")
+@click.option('--model', '-m', default='all', help="Target AI model (e.g. claude-3.5-sonnet, gemini-1.5-pro, all).")
+def add(keyword, error, fix, model):
+    """Add a new wrong-answer note manually (auto-verified)."""
+    note_id = db.add_mistake(keyword, error, fix, target_model=model, is_verified=True)
+    click.echo(f"Successfully added verified note (ID: {note_id}, Model: {model}).")
+
+@main.command()
+@click.argument('mistake')
+@click.argument('fix')
+@click.option('--model', '-m', default='all', help="Which model made this mistake.")
+def pull(mistake, fix, model):
+    """Quick-record: odab pull 'what went wrong' 'what fixed it'"""
+    import re
+    clean = re.sub(r'[^\w\s]', '', mistake)
+    words = [w.capitalize() for w in clean.split() if len(w) > 2][:4]
+    keyword = "_".join(words) if words else "Unknown_Error"
+    note_id = db.add_mistake(keyword, mistake, fix, target_model=model, is_verified=True)
+    click.echo(f"✅ Recorded (ID: {note_id}, Model: {model})")
+    click.echo(f"   Keyword: {keyword}")
+    click.echo(f"   Mistake: {mistake}")
+    click.echo(f"   Fix: {fix}")
+
+@main.command()
+@click.argument('note_id', type=int)
+def approve(note_id):
+    """Approve a wrong-answer note (Veto Pass)."""
+    if db.update_verification(note_id, True):
+        click.echo(f"Note {note_id} approved successfully.")
+    else:
+        click.echo(f"Failed to approve note {note_id} (not found).")
+
+@main.command()
+@click.argument('note_id', type=int)
+def delete(note_id):
+    """Delete a wrong-answer note."""
+    if db.delete_note(note_id):
+        click.echo(f"Note {note_id} deleted successfully.")
+    else:
+        click.echo(f"Failed to delete note {note_id} (not found).")
+
+@main.command()
+@click.argument('note_id_a', type=int)
+@click.argument('note_id_b', type=int)
+@click.option('--solution-c', '-c', required=True, help="Proposed merged solution C.")
+def resolve(note_id_a, note_id_b, solution_c):
+    """Interactively resolve conflict between Note A and Note B."""
+    notes = db.list_all_notes()
+    note_a = next((n for n in notes if n['id'] == note_id_a), None)
+    note_b = next((n for n in notes if n['id'] == note_id_b), None)
+    
+    if not note_a or not note_b:
+        click.echo("Error: One or both notes not found.")
+        return
+
+    click.echo("\n[Odab-Note Conflict Alert 🚨]")
+    click.echo(f"- Note A (Existing/Failed): [ID: {note_id_a}] Keyword: {note_a['keyword']}")
+    click.echo(f"  * Error: {note_a['error_pattern']}")
+    click.echo(f"  * Solution: {note_a['solution']}")
+    click.echo("-" * 40)
+    click.echo(f"- Note B (New/Recent): [ID: {note_id_b}] Keyword: {note_b['keyword']}")
+    click.echo(f"  * Error: {note_b['error_pattern']}")
+    click.echo(f"  * Solution: {note_b['solution']}")
+    click.echo("-" * 40)
+    click.echo(f"- Proposed Merged Option C:")
+    click.echo(f"  * Solution: {solution_c}")
+    click.echo("-" * 40)
+
+    click.echo("\nHow would you like to resolve this conflict?")
+    click.echo("1. Keep Note A (Existing/Failed) and discard B")
+    click.echo("2. Keep Note B (New/Recent) and discard A")
+    click.echo("3. Merge A & B into Option C (New Solution)")
+    
+    choice = click.prompt("Enter option", type=click.Choice(['1', '2', '3']))
+    
+    if choice == '1':
+        db.delete_note(note_id_b)
+        click.echo(f"Resolved: Kept Note {note_id_a}, deleted Note {note_id_b}.")
+    elif choice == '2':
+        db.delete_note(note_id_a)
+        # Note B를 verified 처리
+        db.update_verification(note_id_b, True)
+        click.echo(f"Resolved: Kept Note {note_id_b}, deleted Note {note_id_a}.")
+    elif choice == '3':
+        db.merge_and_replace_notes(note_id_a, note_id_b, solution_c, note_a['keyword'])
+        click.echo(f"Resolved: Note {note_id_b} merged into Note {note_id_a} with Merged Solution C.")
+
+@main.command()
+@click.option('--days', '-d', default=7, type=int, help="Days threshold for time decay.")
+def decay(days):
+    """Manually apply time-decay to decrease weights of obsolete notes."""
+    affected = db.apply_decay(days_threshold=days)
+    click.echo(f"Applied time decay (Threshold: {days} days). Affected {affected} notes.")
+
+@main.command()
+@click.argument('from_id', type=int)
+@click.argument('to_id', type=int)
+@click.option('--type', '-t', default='triggers', type=click.Choice(['conflict', 'triggers']), help="Relation type (conflict or triggers).")
+def link(from_id, to_id, type):
+    """Link two notes with relation (triggers or conflict)."""
+    db.add_relation(from_id, to_id, type)
+    click.echo(f"Successfully linked Note {from_id} -> Note {to_id} as '{type}'.")
+
+@main.command()
+def graph():
+    """Visualize relations and conflicts of wrong-answer notes as a network tree."""
+    notes = db.list_all_notes()
+    if not notes:
+        click.echo("No wrong-answer notes to visualize.")
+        return
+
+    click.echo("\n[ Odab-Note Dependency & Conflict Graph 🕸️ ]\n")
+    for note in notes:
+        note_id = note['id']
+        conflicts = db.get_related_notes_by_type(note_id, 'conflict')
+        triggers = db.get_related_notes_by_type(note_id, 'triggers')
+        
+        # 모델 정보가 all이 아닐 경우 괄호로 추가 표시
+        model_str = f" ({note['target_model']})" if note.get('target_model') and note['target_model'] != 'all' else ""
+        verified_str = "✓" if note['is_verified'] else "✗"
+        
+        click.echo(f"● [ID: {note_id}] {note['keyword']}{model_str} (Count: {note['occurrence_count']}, Verified: {verified_str})")
+        
+        for c in conflicts:
+            click.echo(f"  ├── ⚡ [Conflict] -> [ID: {c['id']}] {c['keyword']}")
+        for t in triggers:
+            click.echo(f"  └── 🔗 [Triggers] -> [ID: {t['id']}] {t['keyword']}")
+        
+        if not conflicts and not triggers:
+            click.echo("  └── (No active relations)")
+        click.echo("")
+
+@main.command()
+def run_server():
+    """Run the OdabNote MCP server."""
+    click.echo("Starting OdabNote MCP Server...")
+    mcp.run()
+
+if __name__ == "__main__":
+    main()

odab_note/database.py

@@ -0,0 +1,298 @@
+import sqlite3
+import os
+import re
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+
+DEFAULT_DB_PATH = os.path.expanduser("~/.gemini/antigravity/odab_note.db")
+
+class OdabNoteDB:
+    def __init__(self, db_path: str = DEFAULT_DB_PATH):
+        self.db_path = db_path
+        # 디렉토리가 없으면 생성
+        os.makedirs(os.path.dirname(self.db_path), exist_ok=True)
+        self.init_db()
+
+    def _get_connection(self):
+        conn = sqlite3.connect(self.db_path)
+        conn.row_factory = sqlite3.Row
+        return conn
+
+    def init_db(self):
+        with self._get_connection() as conn:
+            # 1. 오답노트 테이블 (last_occurred_at, decay_factor, target_model 속성 기본 포함)
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS incorrect_notes (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    keyword TEXT NOT NULL,
+                    error_pattern TEXT NOT NULL,
+                    solution TEXT NOT NULL,
+                    occurrence_count INTEGER DEFAULT 1,
+                    is_verified BOOLEAN DEFAULT 0,
+                    last_occurred_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    decay_factor REAL DEFAULT 0.1,
+                    target_model TEXT DEFAULT 'all'
+                )
+            """)
+            # 2. 세션 메모리 테이블
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS session_memories (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    project TEXT NOT NULL,
+                    summary TEXT NOT NULL,
+                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+            """)
+            # 3. 에이전트 스킬 테이블
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS agent_skills (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    name TEXT UNIQUE NOT NULL,
+                    cmd TEXT NOT NULL,
+                    desc TEXT NOT NULL,
+                    is_verified BOOLEAN DEFAULT 0
+                )
+            """)
+            # 4. 오답 노드 간의 관계 및 상충(Conflict) 테이블
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS incorrect_note_relations (
+                    from_note_id INTEGER,
+                    to_note_id INTEGER,
+                    relation_type TEXT NOT NULL, -- 'conflict', 'triggers', 'parent_of'
+                    PRIMARY KEY (from_note_id, to_note_id),
+                    FOREIGN KEY (from_note_id) REFERENCES incorrect_notes(id) ON DELETE CASCADE,
+                    FOREIGN KEY (to_note_id) REFERENCES incorrect_notes(id) ON DELETE CASCADE
+                )
+            """)
+            conn.commit()
+
+        # 스키마 마이그레이션 (기존 생성 테이블용 하위 호환성 패치)
+        with self._get_connection() as conn:
+            try:
+                conn.execute("ALTER TABLE incorrect_notes ADD COLUMN last_occurred_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP")
+            except sqlite3.OperationalError:
+                pass
+            try:
+                conn.execute("ALTER TABLE incorrect_notes ADD COLUMN decay_factor REAL DEFAULT 0.1")
+            except sqlite3.OperationalError:
+                pass
+            try:
+                conn.execute("ALTER TABLE incorrect_notes ADD COLUMN target_model TEXT DEFAULT 'all'")
+            except sqlite3.OperationalError:
+                pass
+            conn.commit()
+
+    # --- incorrect_notes CRUD ---
+    def add_mistake(self, keyword: str, error_pattern: str, solution: str, target_model: str = 'all', is_verified: bool = False) -> int:
+        with self._get_connection() as conn:
+            # 기존에 동일한 keyword와 error_pattern, target_model이 있는지 확인하여 카운트 증가
+            cursor = conn.execute("""
+                SELECT id, occurrence_count FROM incorrect_notes 
+                WHERE keyword = ? AND error_pattern = ? AND target_model = ?
+            """, (keyword, error_pattern, target_model))
+            row = cursor.fetchone()
+            if row:
+                note_id = row["id"]
+                conn.execute("""
+                    UPDATE incorrect_notes 
+                    SET occurrence_count = occurrence_count + 1, solution = ?, last_occurred_at = CURRENT_TIMESTAMP 
+                    WHERE id = ?
+                """, (solution, note_id))
+                conn.commit()
+                return note_id
+            else:
+                cursor = conn.execute("""
+                    INSERT INTO incorrect_notes (keyword, error_pattern, solution, is_verified, last_occurred_at, decay_factor, target_model) 
+                    VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP, 0.1, ?)
+                """, (keyword, error_pattern, solution, 1 if is_verified else 0, target_model))
+                conn.commit()
+                return cursor.lastrowid
+
+    def query_notes(self, keywords: List[str], only_verified: bool = False) -> List[Dict[str, Any]]:
+        if not keywords:
+            return []
+        
+        # 키워드 매칭 쿼리 (OR 조건)
+        query = "SELECT * FROM incorrect_notes WHERE (" + " OR ".join(["keyword LIKE ?" for _ in keywords]) + ")"
+        params = [f"%{k}%" for k in keywords]
+        
+        if only_verified:
+            query += " AND is_verified = 1"
+            
+        query += " ORDER BY occurrence_count DESC"
+        
+        with self._get_connection() as conn:
+            cursor = conn.execute(query, params)
+            notes = [dict(row) for row in cursor.fetchall()]
+            
+            # 각 오답노트의 2차 연관 및 상충 오답들도 가져와 주입
+            for note in notes:
+                note['conflicts'] = self.get_related_notes_by_type(note['id'], 'conflict')
+                note['relations'] = self.get_related_notes_by_type(note['id'], 'triggers')
+            return notes
+
+    def match_error_trace(self, error_trace: str, target_model: str = 'all', only_verified: bool = False) -> List[Dict[str, Any]]:
+        """Match error trace against wrong-answer note regex patterns and retrieve matches."""
+        notes = self.list_all_notes()
+        matched_notes = []
+        for note in notes:
+            if only_verified and not note['is_verified']:
+                continue
+            
+            # target_model 필터링 (all이거나 혹은 요청한 모델명과 매칭될 때만)
+            note_model = note.get('target_model', 'all')
+            if target_model != 'all' and note_model != 'all' and note_model != target_model:
+                continue
+
+            try:
+                # 정규식 대소문자 구분 없이, 줄바꿈도 매치하도록 컴파일
+                pattern = re.compile(note['error_pattern'], re.IGNORECASE | re.DOTALL)
+                if pattern.search(error_trace):
+                    note_id = note['id']
+                    note['conflicts'] = self.get_related_notes_by_type(note_id, 'conflict')
+                    note['relations'] = self.get_related_notes_by_type(note_id, 'triggers')
+                    
+                    # 매치된 에러이므로 최신 시간 갱신 (감쇠 방지)
+                    with self._get_connection() as conn:
+                        conn.execute("UPDATE incorrect_notes SET last_occurred_at = CURRENT_TIMESTAMP WHERE id = ?", (note_id,))
+                        conn.commit()
+                        
+                    matched_notes.append(note)
+            except re.error:
+                # 패턴 오류 시 단순 텍스트 서브스트링 비교 폴백
+                if note['error_pattern'].lower() in error_trace.lower():
+                    note_id = note['id']
+                    note['conflicts'] = self.get_related_notes_by_type(note_id, 'conflict')
+                    note['relations'] = self.get_related_notes_by_type(note_id, 'triggers')
+                    matched_notes.append(note)
+                    
+        # 가중치 우선 내림차순 정렬하되, target_model이 정확히 일치하는 것을 최우선 정렬 보너스 부여
+        def sort_key(x):
+            model_bonus = 1000 if x.get('target_model') == target_model and target_model != 'all' else 0
+            return x['occurrence_count'] + model_bonus
+
+        matched_notes.sort(key=sort_key, reverse=True)
+        return matched_notes
+
+    def apply_decay(self, days_threshold: int = 7) -> int:
+        """Decrease occurrence_count of notes not triggered for days_threshold days."""
+        with self._get_connection() as conn:
+            # last_occurred_at이 days_threshold보다 과거인 항목들 가중치 차감 (최소 1)
+            cursor = conn.execute("""
+                UPDATE incorrect_notes 
+                SET occurrence_count = MAX(1, CAST(occurrence_count * (1.0 - decay_factor) AS INTEGER))
+                WHERE last_occurred_at < datetime('now', ?) AND occurrence_count > 1
+            """, (f"-{days_threshold} days",))
+            conn.commit()
+            return cursor.rowcount
+
+    def update_verification(self, note_id: int, is_verified: bool) -> bool:
+        with self._get_connection() as conn:
+            cursor = conn.execute(
+                "UPDATE incorrect_notes SET is_verified = ? WHERE id = ?",
+                (1 if is_verified else 0, note_id)
+            )
+            conn.commit()
+            return cursor.rowcount > 0
+
+    def delete_note(self, note_id: int) -> bool:
+        with self._get_connection() as conn:
+            cursor = conn.execute("DELETE FROM incorrect_notes WHERE id = ?", (note_id,))
+            conn.commit()
+            return cursor.rowcount > 0
+
+    def list_all_notes(self) -> List[Dict[str, Any]]:
+        with self._get_connection() as conn:
+            cursor = conn.execute("SELECT * FROM incorrect_notes ORDER BY occurrence_count DESC")
+            return [dict(row) for row in cursor.fetchall()]
+
+    def get_latest_note(self) -> Optional[Dict[str, Any]]:
+        with self._get_connection() as conn:
+            cursor = conn.execute("SELECT * FROM incorrect_notes ORDER BY id DESC LIMIT 1")
+            row = cursor.fetchone()
+            return dict(row) if row else None
+
+    def update_note(self, note_id: int, keyword: str = None, error_pattern: str = None, solution: str = None) -> bool:
+        with self._get_connection() as conn:
+            updates = []
+            params = []
+            if keyword is not None:
+                updates.append("keyword = ?")
+                params.append(keyword)
+            if error_pattern is not None:
+                updates.append("error_pattern = ?")
+                params.append(error_pattern)
+            if solution is not None:
+                updates.append("solution = ?")
+                params.append(solution)
+            if not updates:
+                return False
+            params.append(note_id)
+            cursor = conn.execute(f"UPDATE incorrect_notes SET {', '.join(updates)} WHERE id = ?", params)
+            conn.commit()
+            return cursor.rowcount > 0
+
+    # --- Relations and Conflict Handling ---
+    def add_relation(self, from_id: int, to_id: int, relation_type: str = 'conflict'):
+        with self._get_connection() as conn:
+            conn.execute(
+                "INSERT OR IGNORE INTO incorrect_note_relations (from_note_id, to_note_id, relation_type) VALUES (?, ?, ?)",
+                (from_id, to_id, relation_type)
+            )
+            if relation_type == 'conflict':
+                # 상충 관계는 양방향으로 등록
+                conn.execute(
+                    "INSERT OR IGNORE INTO incorrect_note_relations (from_note_id, to_note_id, relation_type) VALUES (?, ?, ?)",
+                    (to_id, from_id, relation_type)
+                )
+            conn.commit()
+
+    def get_related_notes_by_type(self, note_id: int, relation_type: str) -> List[Dict[str, Any]]:
+        with self._get_connection() as conn:
+            cursor = conn.execute("""
+                SELECT n.* FROM incorrect_notes n
+                JOIN incorrect_note_relations r ON n.id = r.to_note_id
+                WHERE r.from_note_id = ? AND r.relation_type = ?
+            """, (note_id, relation_type))
+            return [dict(row) for row in cursor.fetchall()]
+
+    def merge_and_replace_notes(self, keep_id: int, delete_id: int, merged_solution: str, merged_keyword: str) -> bool:
+        """Merge two conflicting notes into one, update the solution, and delete the other."""
+        with self._get_connection() as conn:
+            # 1. 유지할 노트의 솔루션, 키워드, 카운트 갱신
+            cursor = conn.execute("SELECT occurrence_count FROM incorrect_notes WHERE id = ?", (delete_id,))
+            del_row = cursor.fetchone()
+            del_count = del_row["occurrence_count"] if del_row else 1
+            
+            conn.execute("""
+                UPDATE incorrect_notes 
+                SET solution = ?, keyword = ?, occurrence_count = occurrence_count + ?, is_verified = 1, last_occurred_at = CURRENT_TIMESTAMP
+                WHERE id = ?
+            """, (merged_solution, merged_keyword, del_count, keep_id))
+            
+            # 2. 다른 노트 삭제
+            conn.execute("DELETE FROM incorrect_notes WHERE id = ?", (delete_id,))
+            
+            # 3. 구 관계 정보 클린업 및 업데이트
+            conn.execute("DELETE FROM incorrect_note_relations WHERE from_note_id = ? OR to_note_id = ?", (delete_id, delete_id))
+            conn.commit()
+            return True
+
+
+    # --- agent_skills CRUD ---
+    def register_skill(self, name: str, cmd: str, desc: str, is_verified: bool = False) -> bool:
+        with self._get_connection() as conn:
+            try:
+                conn.execute(
+                    "INSERT OR REPLACE INTO agent_skills (name, cmd, desc, is_verified) VALUES (?, ?, ?, ?)",
+                    (name, cmd, desc, 1 if is_verified else 0)
+                )
+                conn.commit()
+                return True
+            except sqlite3.Error:
+                return False
+
+    def list_skills(self) -> List[Dict[str, Any]]:
+        with self._get_connection() as conn:
+            cursor = conn.execute("SELECT * FROM agent_skills")
+            return [dict(row) for row in cursor.fetchall()]

odab_note/server.py

@@ -0,0 +1,218 @@
+from mcp.server.fastmcp import FastMCP
+from odab_note.database import OdabNoteDB
+import json
+import re
+
+# FastMCP 인스턴스 생성
+mcp = FastMCP("OdabNote")
+db = OdabNoteDB()
+
+@mcp.tool()
+def query_notes(keywords: list[str]) -> str:
+    """Query past mistakes and correct actions by keywords.
+
+    Use this at the beginning of a task to fetch relevant wrong-answer notes to avoid repeating past mistakes.
+    """
+    notes = db.query_notes(keywords)
+    if not notes:
+        return "No relevant past mistakes found for keywords: " + ", ".join(keywords)
+
+    result = [f"Found {len(notes)} wrong-answer notes:"]
+    for idx, note in enumerate(notes, 1):
+        status = "Verified" if note['is_verified'] else "Draft (Not Verified)"
+        result.append(
+            f"{idx}. [{status}] (Weight: {note['occurrence_count']})\n"
+            f"   - Target Keyword: {note['keyword']}\n"
+            f"   - Error/Mistake Pattern: {note['error_pattern']}\n"
+            f"   - Correct Solution: {note['solution']}"
+        )
+    return "\n\n".join(result)
+
+@mcp.tool()
+def record_mistake(keyword: str, error_pattern: str, solution: str, target_model: str = "all") -> str:
+    """Record a new mistake or error pattern with its correct solution.
+
+    Use this tool when a build error occurs, or when you receive negative feedback from the user.
+    target_model can be set to a specific model name (e.g. 'gemini-3.5-flash', 'claude-3.5-sonnet') to track model-specific mistakes.
+    """
+    note_id = db.add_mistake(keyword, error_pattern, solution, target_model=target_model)
+    return f"Successfully recorded mistake (ID: {note_id}, Model: {target_model}). Status is set to Draft. Ask the user or CLI to verify it."
+
+@mcp.tool()
+def propose_conflict_resolution(note_id_a: int, note_id_b: int, proposed_solution_c: str) -> str:
+    """Propose a resolution for two conflicting wrong-answer notes A and B.
+
+    This generates an option block for the user to select A, B, or a merged solution C.
+    """
+    # A와 B의 관계를 conflict로 기록
+    db.add_relation(note_id_a, note_id_b, 'conflict')
+    
+    notes = db.list_all_notes()
+    note_a = next((n for n in notes if n['id'] == note_id_a), None)
+    note_b = next((n for n in notes if n['id'] == note_id_b), None)
+    
+    if not note_a or not note_b:
+        return "Failed to propose resolution: One or both notes not found."
+
+    report = (
+        f"[Odab-Note Conflict Alert 🚨]\n"
+        f"A conflict has been detected between note {note_id_a} and note {note_id_b}.\n\n"
+        f"- Note A (Existing/Failed): [ID: {note_id_a}] Keyword: {note_a['keyword']}\n"
+        f"  * Error: {note_a['error_pattern']}\n"
+        f"  * Solution: {note_a['solution']}\n\n"
+        f"- Note B (New/Recent): [ID: {note_id_b}] Keyword: {note_b['keyword']}\n"
+        f"  * Error: {note_b['error_pattern']}\n"
+        f"  * Solution: {note_b['solution']}\n\n"
+        f"- Proposed Merged Option C:\n"
+        f"  * Solution: {proposed_solution_c}\n\n"
+        f"Please run the CLI to resolve this conflict:\n"
+        f"  `odab-note resolve {note_id_a} {note_id_b} --solution-c \"{proposed_solution_c}\"`\n"
+        f"Or choose to reject B and keep A by running:\n"
+        f"  `odab-note delete {note_id_b}`"
+    )
+    return report
+
+@mcp.tool()
+def resolve_conflict_merge(keep_id: int, delete_id: int, merged_solution: str, merged_keyword: str) -> str:
+    """Resolve a conflict by merging note `delete_id` into `keep_id` and updating it with `merged_solution`."""
+    success = db.merge_and_replace_notes(keep_id, delete_id, merged_solution, merged_keyword)
+    if success:
+        return f"Successfully merged note {delete_id} into note {keep_id} with new solution."
+    else:
+        return "Failed to resolve conflict."
+
+@mcp.tool()
+def register_skill(name: str, cmd: str, desc: str) -> str:
+    """Register a verified, reusable skill (workflow command).
+
+    Use this to save successful execution commands or steps for future runs.
+    """
+    success = db.register_skill(name, cmd, desc)
+    if success:
+        return f"Successfully registered skill '{name}'."
+    else:
+        return f"Failed to register skill '{name}'."
+
+@mcp.tool()
+def match_error_trace(error_trace: str, target_model: str = "all", only_verified: bool = False) -> str:
+    """Match a stack trace or compilation error against database regexes.
+
+    Use this tool when an execution or compilation error occurs during coding to find a correction.
+    """
+    notes = db.match_error_trace(error_trace, target_model=target_model, only_verified=only_verified)
+    if not notes:
+        return "No matching past error patterns found."
+
+    result = [f"Found {len(notes)} matching wrong-answer notes:"]
+    for idx, note in enumerate(notes, 1):
+        status = "Verified" if note['is_verified'] else "Draft"
+        result.append(
+            f"{idx}. [{status}] (Weight: {note['occurrence_count']}, Model: {note.get('target_model', 'all')})\n"
+            f"   - Target Keyword: {note['keyword']}\n"
+            f"   - Match Pattern: {note['error_pattern']}\n"
+            f"   - Correct Solution: {note['solution']}"
+        )
+    return "\n\n".join(result)
+
+@mcp.tool()
+def auto_record(what_went_wrong: str, what_fixed_it: str, target_model: str = "all") -> str:
+    """Quick-record a mistake from plain language. This is the 'odab pull' trigger.
+
+    When the user says '오답 넣어' or 'odab pull':
+    1. Analyze your recent conversation to identify the error and the fix.
+    2. Call this tool with a plain-language description. No regex needed.
+    3. The keyword is auto-generated from the description.
+
+    Args:
+        what_went_wrong: Plain description of the mistake (e.g. 'used LKS venv instead of local venv')
+        what_fixed_it: Plain description of the fix (e.g. 'created dedicated .venv inside project dir')
+        target_model: Which model made this mistake (e.g. 'gemini-3.5-flash', 'claude-3.5-sonnet', 'all')
+    """
+    # Auto-generate keyword from description
+    clean = re.sub(r'[^\w\s]', '', what_went_wrong)
+    words = [w.capitalize() for w in clean.split() if len(w) > 2][:4]
+    keyword = "_".join(words) if words else "Unknown_Error"
+
+    note_id = db.add_mistake(keyword, what_went_wrong, what_fixed_it, target_model=target_model)
+    return (
+        f"✅ Recorded (ID: {note_id}, Model: {target_model})\n"
+        f"   Keyword: {keyword}\n"
+        f"   Mistake: {what_went_wrong}\n"
+        f"   Fix: {what_fixed_it}"
+    )
+
+@mcp.tool()
+def revise_last(correction: str) -> str:
+    """Revise the most recently recorded note based on user feedback.
+
+    Trigger: '오답 수정' or 'odab fix'
+
+    The user may say something like:
+      '오답 수정 파일명을 그렇게 바꾸지 말라는거야 다른거랑 맞춰서 넣어야지'
+
+    You must:
+    1. Get the latest note from the database.
+    2. Re-interpret the user's feedback to update the mistake description and/or fix.
+    3. Call this tool with the corrected content.
+    4. REPORT what changed to the user.
+
+    Args:
+        correction: The corrected content. Format as 'mistake: ... | fix: ...' or just the part to change.
+    """
+    latest = db.get_latest_note()
+    if not latest:
+        return "❌ No notes found to revise."
+
+    note_id = latest['id']
+
+    # Parse correction — if it contains 'mistake:' and 'fix:', split them
+    if '|' in correction:
+        parts = correction.split('|', 1)
+        new_mistake = parts[0].strip()
+        new_fix = parts[1].strip()
+        db.update_note(note_id, error_pattern=new_mistake, solution=new_fix)
+        # Regenerate keyword
+        clean = re.sub(r'[^\w\s]', '', new_mistake)
+        words = [w.capitalize() for w in clean.split() if len(w) > 2][:4]
+        keyword = "_".join(words) if words else latest['keyword']
+        db.update_note(note_id, keyword=keyword)
+    else:
+        # Update the solution/fix part only
+        db.update_note(note_id, solution=correction)
+        keyword = latest['keyword']
+        new_mistake = latest['error_pattern']
+        new_fix = correction
+
+    return (
+        f"📝 Revised note (ID: {note_id})\n"
+        f"   Keyword: {keyword}\n"
+        f"   Mistake: {new_mistake}\n"
+        f"   Fix: {new_fix}"
+    )
+
+@mcp.tool()
+def delete_last() -> str:
+    """Delete the most recently recorded note.
+
+    Trigger: '오답 삭제' or 'odab del'
+
+    You must REPORT what was deleted to the user.
+    """
+    latest = db.get_latest_note()
+    if not latest:
+        return "❌ No notes found to delete."
+
+    note_id = latest['id']
+    keyword = latest['keyword']
+    db.delete_note(note_id)
+    return (
+        f"🗑️ Deleted note (ID: {note_id})\n"
+        f"   Keyword: {keyword}\n"
+        f"   Was: {latest['error_pattern']}"
+    )
+
+def run():
+    mcp.run()
+
+if __name__ == "__main__":
+    run()

odab_note-0.1.0.dist-info/METADATA

@@ -0,0 +1,339 @@
+Metadata-Version: 2.4
+Name: odab-note
+Version: 0.1.0
+Summary: Wrong-answer vaccine system for AI agents — learns error patterns and prevents repeated mistakes via MCP
+Author-email: Logan Lee <logan@logans.company>
+Requires-Python: >=3.10
+Requires-Dist: click>=8.0.0
+Requires-Dist: mcp>=0.1.0
+Description-Content-Type: text/markdown
+
+# OdabNote — Wrong-Answer Vaccine System for AI Agents
+
+[![Sponsor](https://img.shields.io/badge/Sponsor-♥-ea4aaa?style=for-the-badge&logo=github-sponsors)](https://github.com/sponsors/hacker3699-max)
+[![License](https://img.shields.io/badge/License-All_Rights_Reserved-blue?style=for-the-badge)](LICENSE)
+
+> **Teach AI agents to never repeat the same coding mistake twice.**
+
+OdabNote is a local MCP (Model Context Protocol) server that captures error patterns, stores verified solutions, and automatically matches future errors against its database — acting as an immune system for AI coding agents.
+
+---
+
+## Why OdabNote?
+
+AI coding agents (Claude Code, Codex, Cursor, Gemini, etc.) repeatedly make the same mistakes across sessions. They forget what went wrong last time. OdabNote solves this by:
+
+1. **Recording** error patterns with their verified fixes
+2. **Matching** new errors against the database in real-time
+3. **Preventing** the same mistake from happening again
+4. **Tracking** which AI models make which mistakes (model-specific blacklists)
+5. **Decaying** outdated patterns so the knowledge stays fresh
+
+---
+
+## Quick Start
+
+### Prerequisites
+
+- Python 3.10+
+- pip
+
+### Installation
+
+```bash
+git clone https://github.com/hacker3699-max/OdabNote.git
+cd OdabNote
+python3 -m venv .venv
+.venv/bin/pip install -e .
+```
+
+### Verify Installation
+
+```bash
+.venv/bin/odab --help
+```
+
+Expected output:
+```
+Usage: odab [OPTIONS] COMMAND [ARGS]...
+
+  OdabNote CLI - Manage wrong-answer notes for AI Agents.
+
+Commands:
+  add         Add a new wrong-answer note manually (auto-verified).
+  approve     Approve a wrong-answer note (Veto Pass).
+  decay       Manually apply time-decay to decrease weights of obsolete notes.
+  delete      Delete a wrong-answer note.
+  graph       Visualize relations and conflicts of wrong-answer notes.
+  link        Link two notes with relation (triggers or conflict).
+  list        List all wrong-answer notes.
+  resolve     Interactively resolve conflict between Note A and Note B.
+  run-server  Run the OdabNote MCP server.
+  show        Show details of a specific wrong-answer note.
+```
+
+---
+
+## Usage Guide
+
+### How It Works (Natural Language)
+
+You don't need to type CLI commands. Just talk to your AI agent in natural language.
+
+**Step 1 — Agent makes a mistake. You say: `오답 넣어` or `odab pull`**
+
+> You asked the agent to modify `config.yaml`, but it created a new `config_new.yaml` instead.
+
+```
+You:  Why did you create a new file? I said modify the existing one. odab pull
+
+Agent: ✅ Recorded (ID: 13, Model: claude-opus-4.6)
+         Keyword: Created_New_File_Instead_Modifying
+         Mistake: User asked to modify existing file but agent created a new file instead
+         Fix: When user says 'modify', always edit the existing file in place.
+              Never create a new file unless explicitly asked.
+```
+
+**Step 2 — Not happy with the note? Say: `오답 수정` or `odab fix`**
+
+```
+You:  odab fix I meant you should always back up config files before editing them
+
+Agent: 📝 Revised note (ID: 13)
+         Keyword: Config_File_Backup_First
+         Mistake: Modified config file without creating a backup first
+         Fix: Always create a backup copy before modifying any config file
+```
+
+**Step 3 — Want to remove it entirely? Say: `오답 삭제` or `odab del`**
+
+```
+You:  odab del
+
+Agent: 🗑️ Deleted note (ID: 13)
+         Keyword: Config_File_Backup_First
+         Was: Modified config file without creating a backup first
+```
+
+**That's it.** Three phrases to remember:
+
+| Korean | English | What it does |
+|--------|---------|-------------|
+| `오답 넣어` | `odab pull` | Record the last mistake |
+| `오답 수정` | `odab fix` | Revise the note |
+| `오답 삭제` | `odab del` | Delete the note |
+
+---
+
+### CLI Reference
+
+#### 1. Record a Mistake
+
+When you encounter an error and fix it, record it:
+
+```bash
+odab add \
+  -k "ZeroDivisionPrevention" \
+  -e "ZeroDivisionError: division by zero" \
+  -f "Check if denominator == 0 before dividing and return a safe default value" \
+  -m "all"
+```
+
+| Flag | Description |
+|------|-------------|
+| `-k` | Keyword name for this mistake (unique identifier) |
+| `-e` | Error pattern (supports regex) |
+| `-f` | The correct fix / solution |
+| `-m` | Target model (`all`, `gemini-3.5-flash`, `claude-3.5-sonnet`, etc.) |
+
+### 2. List All Mistakes
+
+```bash
+odab list
+```
+
+```
+ID   | Keyword              | Model            | Count | Verified | Error Pattern
+-----------------------------------------------------------------------------------------------
+1    | ZeroDivisionPrev...  | all              | 1     | Yes      | ZeroDivisionError: division by...
+2    | Surface_Only_Fix     | gemini-3.5-flash | 1     | Yes      | Fixed surface only, left old refs...
+```
+
+### 3. View Details
+
+```bash
+odab show 1
+```
+
+### 4. Visualize Relations
+
+```bash
+odab graph
+```
+
+```
+[ Odab-Note Dependency & Conflict Graph 🕸️ ]
+
+● [ID: 1] ZeroDivisionPrevention (Count: 1, Verified: ✓)
+  └── (No active relations)
+
+● [ID: 2] Surface_Only_Fix (Count: 1, Verified: ✓)
+  └── 🔗 [Triggers] -> [ID: 3] No_Full_Audit_Before_Done
+```
+
+### 5. Link Related Mistakes
+
+```bash
+odab link 2 3 --type triggers
+```
+
+### 6. Resolve Conflicts
+
+When two notes contradict each other:
+
+```bash
+odab resolve 1 2 --solution-c "Merged solution that combines both approaches"
+```
+
+### 7. Apply Time Decay
+
+Decrease weight of notes not triggered in N days:
+
+```bash
+odab decay --days 30
+```
+
+---
+
+## MCP Server Integration
+
+### For Gemini (Antigravity)
+
+Add to `~/.gemini/antigravity/mcp_config.json`:
+
+```json
+{
+  "odab-note": {
+    "command": "/path/to/OdabNote/.venv/bin/python",
+    "args": ["-m", "odab_note.server"],
+    "env": {
+      "PYTHONPATH": "/path/to/OdabNote/src"
+    }
+  }
+}
+```
+
+### For Claude Code / Cursor / Cline
+
+Add to your MCP settings (e.g. `.cursor/mcp.json` or `claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "odab-note": {
+      "command": "/path/to/OdabNote/.venv/bin/python",
+      "args": ["-m", "odab_note.server"],
+      "env": {
+        "PYTHONPATH": "/path/to/OdabNote/src"
+      }
+    }
+  }
+}
+```
+
+### Available MCP Tools
+
+| Tool | Description |
+|------|-------------|
+| `query_notes(keywords)` | Search past mistakes by keyword before starting work |
+| `match_error_trace(error_trace, target_model)` | Match a stack trace against the database to find a known fix |
+| `record_mistake(keyword, error_pattern, solution, target_model)` | Record a new mistake with its solution |
+| `propose_conflict_resolution(note_id_a, note_id_b, proposed_solution_c)` | Propose resolution for conflicting notes |
+| `resolve_conflict_merge(keep_id, delete_id, merged_solution, merged_keyword)` | Execute a conflict merge |
+| `register_skill(name, cmd, desc)` | Save a verified workflow command for reuse |
+
+---
+
+## Testing
+
+### Run the E2E Verification Script
+
+```bash
+cd OdabNote
+.venv/bin/python tests/test_mcp.py
+```
+
+Expected output:
+```
+🔍 [TEST 1] Query Notes with keyword 'SMC'...
+Result:
+Found 2 wrong-answer notes:
+...
+
+🔍 [TEST 2] Match Error Trace for SMC Timeout...
+Result:
+Found 1 matching wrong-answer notes:
+...
+
+🔍 [TEST 3] Match ZeroDivisionError Trace...
+Result:
+Found 1 matching wrong-answer notes:
+  - Target Keyword: ZeroDivisionPrevention
+  - Correct Solution: Check if denominator == 0 before dividing...
+```
+
+### Manual End-to-End Test
+
+1. **Create a bug:**
+   ```bash
+   echo 'print(1/0)' > /tmp/bad.py
+   python3 /tmp/bad.py  # ZeroDivisionError
+   ```
+
+2. **Record it:**
+   ```bash
+   odab add -k "DivByZero" -e "ZeroDivisionError" -f "Guard with if x != 0" -m "all"
+   ```
+
+3. **Verify it matches:**
+   ```bash
+   .venv/bin/python -c "
+   from odab_note.server import match_error_trace
+   print(match_error_trace('ZeroDivisionError: division by zero'))
+   "
+   ```
+
+4. **Confirm the vaccine is prescribed** — the output should show the fix you recorded.
+
+---
+
+## Project Structure
+
+```
+OdabNote/
+├── src/odab_note/
+│   ├── __init__.py
+│   ├── server.py      # FastMCP server with 6 tools
+│   ├── database.py    # SQLite DB with regex matching, decay, relations
+│   └── cli.py         # Click CLI with 10 subcommands
+├── tests/
+│   ├── test_mcp.py    # E2E MCP tool verification
+│   └── buggy_script.py # Intentional bug for testing
+├── docs/              # PRD, philosophy, tier matrix
+├── SKILL.md           # Agent instruction file (for Claude Code, Codex, etc.)
+├── pyproject.toml
+└── README.md
+```
+
+## Database Location
+
+The SQLite database is stored at:
+```
+~/.gemini/antigravity/odab_note.db
+```
+
+---
+
+## License
+
+© Logan's Company. All rights reserved.

odab_note-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+odab_note/__init__.py,sha256=dFzoGs9TeaV0RVL-OzaI_2-afx_jmBvVibV2zcfIJrw,20
+odab_note/cli.py,sha256=EWBaILjS_sYOVU_I6Rv2kRbGK1XkFDWctSMZUoYIIVI,8070
+odab_note/database.py,sha256=pePQMvivnbAibxOwa1jjIsXAiW-aQPssqEnNo7m1oYY,14336
+odab_note/server.py,sha256=7_tAVLF9zz9VxzidWoL-7BnaZGTCPzo6bxec7zHAYPc,8837
+odab_note-0.1.0.dist-info/METADATA,sha256=X87YEf3jd-uMjnzBa2EkVecdwyiXNQjozUTmQctQeOY,9077
+odab_note-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+odab_note-0.1.0.dist-info/entry_points.txt,sha256=2Nm0LsEpYxilaf0cZcoHmObefdbfdth2Az5OROl3UtU,77
+odab_note-0.1.0.dist-info/RECORD,,

odab_note-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

odab_note-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+odab = odab_note.cli:main
+odab-note = odab_note.server:run