🔗 Integrando Vault Obsidian com Intelecto

#!/usr/bin/env python3
"""
bridge.py — Sincroniza vault Obsidian com memória SQLite do Intelecto
Uso: python bridge.py [--incremental]
"""
import sqlite3, pathlib, re, hashlib, sys
from datetime import datetime

VAULT_DIR = pathlib.Path.home() / "vault"
WIKI_DIR = VAULT_DIR / "wiki"
DB_PATH = pathlib.Path.home() / ".intelecto" / "intelecto.db"
SYNC_LOG = VAULT_DIR / ".last_sync"

def get_db():
    conn = sqlite3.connect(DB_PATH)
    # Garante que a tabela existe
    conn.execute("""
        CREATE VIRTUAL TABLE IF NOT EXISTS memories
        USING fts5(content, source UNINDEXED, page_id UNINDEXED)
    """)
    return conn

def parse_index(index_path: pathlib.Path) -> list[dict]:
    """Extrai entradas do index.md: [[page]] — resumo"""
    entries = []
    pattern = re.compile(r'\[\[([^\]]+)\]\].*?—\s*(.+)$', re.MULTILINE)
    text = index_path.read_text(encoding='utf-8')
    for match in pattern.finditer(text):
        page_name, summary = match.groups()
        entries.append({'page': page_name.strip(), 'summary': summary.strip()})
    return entries

def sync_page(conn, page_name: str, summary: str):
    """Lê a página wiki e insere no SQLite como memória estruturada"""
    page_file = WIKI_DIR / f"{page_name}.md"
    if not page_file.exists():
        return

    content = page_file.read_text(encoding='utf-8')
    # Extrai apenas o corpo (sem frontmatter YAML)
    body = re.sub(r'^---.*?---\n', '', content, flags=re.DOTALL)[:600]

    page_id = hashlib.md5(page_name.encode()).hexdigest()[:8]
    memory_text = f"[VAULT:{page_name}] {summary}\n{body}"

    # Remove entrada anterior desta página se existir
    conn.execute("DELETE FROM memories WHERE page_id = ?", [page_id])
    conn.execute(
        "INSERT INTO memories(content, source, page_id) VALUES (?, 'vault', ?)",
        [memory_text, page_id]
    )

def main():
    incremental = '--incremental' in sys.argv
    conn = get_db()
    index_path = WIKI_DIR / "index.md"

    if not index_path.exists():
        print("index.md não encontrado. Configure o vault primeiro.")
        return

    entries = parse_index(index_path)
    synced = 0

    for entry in entries:
        page_file = WIKI_DIR / f"{entry['page']}.md"
        if incremental and SYNC_LOG.exists():
            last_sync = SYNC_LOG.stat().st_mtime
            if page_file.exists() and page_file.stat().st_mtime < last_sync:
                continue  # Não modificada desde último sync
        sync_page(conn, entry['page'], entry['summary'])
        synced += 1

    conn.commit()
    SYNC_LOG.write_text(datetime.now().isoformat())
    print(f"Sincronizadas {synced} páginas do vault → SQLite Intelecto")

if __name__ == "__main__":
    main()

📥 Fluxo de Ingestão via Telegram

from telegram import Update
from telegram.ext import CommandHandler, ContextTypes
import httpx, pathlib, datetime

VAULT_RAW = pathlib.Path.home() / "vault" / "raw"

async def ingere_handler(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
    """Handler para /ingere [URL ou texto]"""
    args = ' '.join(ctx.args) if ctx.args else ''
    if not args:
        await update.message.reply_text("Uso: /ingere [URL ou texto a ingerir]")
        return

    # Se for URL, busca o conteúdo
    if args.startswith('http'):
        await update.message.reply_text("⏳ Buscando conteúdo da URL...")
        async with httpx.AsyncClient() as client:
            resp = await client.get(args, timeout=15)
            content = f"URL: {args}\n\n{resp.text[:5000]}"
    else:
        content = args

    # Salva em raw/
    timestamp = datetime.datetime.now().strftime('%Y-%m-%d-%H%M')
    filename = VAULT_RAW / f"raw-{timestamp}.md"
    filename.write_text(f"---\norigem: telegram\ndata: {timestamp}\n---\n\n{content}")

    await update.message.reply_text(
        f"✅ Salvo em raw/raw-{timestamp}.md\n"
        f"Execute o pipeline de ingestão para compilar no wiki."
    )

# Registrar o handler no Application
app.add_handler(CommandHandler("ingere", ingere_handler))

#!/usr/bin/env python3
"""
watcher.py — Monitora wiki/ e sincroniza com SQLite automaticamente
Dependência: pip install watchdog
"""
import time, subprocess, pathlib
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler

WIKI_DIR = pathlib.Path.home() / "vault" / "wiki"
BRIDGE_SCRIPT = pathlib.Path.home() / "bridge.py"
DEBOUNCE_SECONDS = 5  # Evita sync duplo em saves rápidos

class WikiChangeHandler(FileSystemEventHandler):
    def __init__(self):
        self._last_sync = 0

    def on_modified(self, event):
        if event.is_directory or not event.src_path.endswith('.md'):
            return
        now = time.time()
        if now - self._last_sync < DEBOUNCE_SECONDS:
            return  # Debounce
        self._last_sync = now
        page = pathlib.Path(event.src_path).stem
        print(f"Mudança detectada: {page} — sincronizando...")
        subprocess.run(
            ["python", str(BRIDGE_SCRIPT), "--incremental"],
            capture_output=True
        )
        print(f"Sync concluído para {page}")

if __name__ == "__main__":
    observer = Observer()
    observer.schedule(WikiChangeHandler(), str(WIKI_DIR), recursive=False)
    observer.start()
    print(f"Monitorando {WIKI_DIR}...")
    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        observer.stop()
    observer.join()