@allansantos-dev/smart-tool 0.0.0-stage → 0.9.1

package/tray.py

@@ -0,0 +1,245 @@
+#!/usr/bin/env python3
+"""Ícone na bandeja do sistema do Smart Tool — visibilidade de que o daemon está de
+pé, e ponto único de "se caiu, sobe de novo" que não depende de nenhum host MCP
+cooperar. Processo separado do daemon (mesma relação que `daemon_launcher` já tem com
+`smart_tool_daemon.py`): matar o tray não mata o daemon.
+
+Uso: `pythonw.exe tray.py` (sem console) — entrypoint apontado pelo mecanismo de
+autostart (Tarefa Agendada ou atalho de inicialização).
+"""
+import json
+import os
+import sys
+import threading
+import time
+import urllib.request
+import webbrowser
+
+from PIL import Image, ImageDraw
+import pystray
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import autostart
+import daemon_launcher
+import update_check
+
+POLL_INTERVAL_S = 45
+UPDATE_CHECK_INTERVAL_S = 24 * 3600
+SETUP_URL = "http://127.0.0.1:8765/setup"
+
+_STATE_LOCK = threading.Lock()
+_state = {"health": "starting", "update": None}
+
+
+def _make_icon_image(color):
+    size = 64
+    img = Image.new("RGBA", (size, size), (0, 0, 0, 0))
+    draw = ImageDraw.Draw(img)
+    margin = 8
+    draw.ellipse((margin, margin, size - margin, size - margin), fill=color)
+    return img
+
+
+_GREEN = _make_icon_image((47, 138, 76, 255))
+_YELLOW = _make_icon_image((219, 164, 26, 255))
+_RED = _make_icon_image((194, 59, 59, 255))
+_ICONS = {
+    "ok": _GREEN,
+    "starting": _YELLOW,
+    "needs_key": _YELLOW,
+    "needs_models": _YELLOW,
+    "catalog_unavailable": _YELLOW,
+    "config_corrupt": _YELLOW,
+    "status_error": _YELLOW,
+    "down": _RED,
+}
+
+_TITLES = {
+    "ok": "Smart Tool - daemon running",
+    "starting": "Smart Tool - starting the daemon...",
+    "needs_key": "Smart Tool - model gateway unavailable",
+    "needs_models": "Smart Tool - choose the models in settings",
+    "catalog_unavailable": "Smart Tool - model catalog unavailable",
+    "config_corrupt": "Smart Tool - settings file has an error",
+    "status_error": "Smart Tool - failed to read the settings",
+    "down": "Smart Tool - daemon down",
+}
+
+
+def _set_state(health, icon=None):
+    with _STATE_LOCK:
+        if _state["health"] == health:
+            return
+        _state["health"] = health
+    if icon is not None:
+        icon.icon = _ICONS[health]
+        icon.title = _TITLES[health]
+
+
+def _configuration_state(url):
+    with urllib.request.urlopen(url.rstrip("/") + "/setup/status", timeout=5) as response:
+        payload = json.load(response)
+    return payload["models_status"]
+
+
+def _indicator_state(model_status):
+    if model_status == "ready":
+        return "ok"
+    return model_status if model_status in _TITLES else "status_error"
+
+
+def _poll_loop(icon):
+    while True:
+        try:
+            url = daemon_launcher.read_registry()
+            # Timeout maior que o default: aqui um falso negativo custa um spawn inútil de
+            # daemon, e o polling é a cada 45s — nada espera por esta resposta.
+            if url and daemon_launcher.health(url["url"], timeout=3):
+                daemon_url = url["url"]
+            else:
+                _set_state("starting", icon)
+                daemon_url = daemon_launcher.ensure_daemon_running()
+            try:
+                status = _configuration_state(daemon_url)
+                _set_state(_indicator_state(status), icon)
+            except Exception:
+                _set_state("status_error", icon)
+        except Exception:
+            _set_state("down", icon)
+        time.sleep(POLL_INTERVAL_S)
+
+
+def _update_loop(icon):
+    while True:
+        try:
+            latest = update_check.newer_version()
+        except Exception:
+            latest = None
+        if latest and latest != _state["update"]:
+            _state["update"] = latest
+            icon.update_menu()
+            icon.notify(f"Smart Tool {latest} is available. Update with: {update_check.UPDATE_COMMAND}", "Smart Tool")
+        time.sleep(UPDATE_CHECK_INTERVAL_S)
+
+
+def _update_label(item):
+    return f"Update to {_state['update']} (copy command)"
+
+
+def _copy_update_command(icon, item):
+    import subprocess
+    subprocess.run(["clip.exe"], input=update_check.UPDATE_COMMAND.encode("ascii"), check=True,
+                   creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0))
+    icon.notify(f"Copied: {update_check.UPDATE_COMMAND}. Paste it in a terminal.", "Smart Tool")
+
+
+def _open_setup(icon, item):
+    registry = daemon_launcher.read_registry()
+    webbrowser.open((registry["url"].rstrip("/") + "/setup") if registry else SETUP_URL)
+
+
+def _open_projects(icon, item):
+    def run():
+        try:
+            url = daemon_launcher.ensure_daemon_running()
+            webbrowser.open(url.rstrip("/") + "/projects")
+        except Exception as exc:
+            icon.notify(f"Could not open the projects: {exc}", "Smart Tool")
+    threading.Thread(target=run, daemon=True).start()
+
+
+def _add_project(icon, item):
+    def run():
+        try:
+            import folder_picker
+            folder_picker.register_from_tray()
+        except Exception as exc:
+            icon.notify(f"Could not select the folder: {exc}", "Smart Tool")
+    threading.Thread(target=run, daemon=True).start()
+
+
+def _autostart_checked(item):
+    try:
+        return autostart.status()["installed"]
+    except Exception:
+        return False
+
+
+_autostart_busy = threading.Lock()
+
+
+def _toggle_autostart(icon, item):
+    if not _autostart_busy.acquire(blocking=False):
+        return  # já tem uma troca em andamento — clique duplo ignorado, não enfileirado
+
+    def _run():
+        try:
+            if autostart.status()["installed"]:
+                autostart.remove()
+            else:
+                result = autostart.install()
+                if result.get("method") == "startup_folder" and result.get("fallback_reason"):
+                    icon.notify(
+                        f"Scheduled Task unavailable ({result['fallback_reason']}); using the Startup folder.",
+                        "Smart Tool",
+                    )
+        except Exception as exc:
+            icon.notify(f"Failed to change automatic start: {exc}", "Smart Tool")
+        finally:
+            _autostart_busy.release()
+            icon.update_menu()
+
+    threading.Thread(target=_run, daemon=True).start()
+
+
+def _quit(icon, item):
+    icon.stop()
+
+
+def _single_instance_handle():
+    """Impede dois ícones quando o atalho e o autostart rodam juntos."""
+    if sys.platform != "win32":
+        return None
+    import ctypes
+
+    kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+    kernel32.CreateMutexW.argtypes = (ctypes.c_void_p, ctypes.c_int, ctypes.c_wchar_p)
+    kernel32.CreateMutexW.restype = ctypes.c_void_p
+    handle = kernel32.CreateMutexW(None, False, "Local\\SmartToolTray")
+    if not handle:
+        raise OSError(ctypes.get_last_error(), "Could not start the Smart Tool icon")
+    if ctypes.get_last_error() == 183:  # ERROR_ALREADY_EXISTS
+        kernel32.CloseHandle(ctypes.c_void_p(handle))
+        return False
+    return handle
+
+
+def main():
+    handle = _single_instance_handle()
+    if handle is False:
+        return
+    icon = pystray.Icon(
+        "smart-tool",
+        icon=_ICONS["starting"],
+        title=_TITLES["starting"],
+        menu=pystray.Menu(
+            pystray.MenuItem("Projects and indexing…", _open_projects, default=True),
+            pystray.MenuItem("Index a folder…", _add_project),
+            pystray.MenuItem("Open settings", _open_setup),
+            pystray.MenuItem("Start with Windows", _toggle_autostart, checked=_autostart_checked),
+            pystray.MenuItem(_update_label, _copy_update_command, visible=lambda item: bool(_state["update"])),
+            pystray.MenuItem("Quit", _quit),
+        ),
+    )
+    threading.Thread(target=_poll_loop, args=(icon,), daemon=True).start()
+    threading.Thread(target=_update_loop, args=(icon,), daemon=True).start()
+    try:
+        icon.run()
+    finally:
+        if handle:
+            import ctypes
+            ctypes.windll.kernel32.CloseHandle(ctypes.c_void_p(handle))
+
+
+if __name__ == "__main__":
+    main()

package/update_check.py

@@ -0,0 +1,22 @@
+"""Newer Smart Tool release on npm, for the tray notice. Updating is running the install command again."""
+import json
+import urllib.request
+
+import version
+
+PACKAGE = "@allansantos-dev/smart-tool"
+REGISTRY_URL = "https://registry.npmjs.org/@allansantos-dev%2Fsmart-tool/latest"
+UPDATE_COMMAND = f"npx {PACKAGE}@latest install"
+
+
+def _parts(value):
+    return tuple(int(part) for part in str(value).split("-")[0].split("."))
+
+
+def newer_version(timeout=10):
+    """The latest version on npm when it is newer than the installed one, else None."""
+    request = urllib.request.Request(REGISTRY_URL, headers={"User-Agent": version.user_agent(),
+                                                            "Accept": "application/json"})
+    with urllib.request.urlopen(request, timeout=timeout) as response:
+        latest = json.load(response)["version"]
+    return latest if _parts(latest) > _parts(version.VERSION) else None

package/usage_meter.py

@@ -0,0 +1,124 @@
+"""Consumo por projeto/visão. Só guarda contagens, modelos e horários, nunca conteúdo."""
+import contextlib
+import contextvars
+import datetime
+import json
+import math
+import time
+
+import project_identity
+import project_store
+
+_CONTEXT=contextvars.ContextVar('smart_usage',default=None)
+_PHASES={'scope':'scope','embedding_query':'query_embedding','model_probe':'embedding_probe',
+         'indexing':'index_embedding','reranking':'rerank'}
+
+
+@contextlib.contextmanager
+def job(root,view,job_id):
+    value={'project_id':project_identity.project_id(root),'view_id':view['view_id'],
+           'view_label':view['label'],'job_id':job_id,'purpose':'other'}
+    token=_CONTEXT.set(value)
+    try:yield
+    finally:_CONTEXT.reset(token)
+
+
+def phase(name):
+    current=_CONTEXT.get()
+    if current and name in _PHASES:_CONTEXT.set({**current,'purpose':_PHASES[name]})
+
+
+def _tables(db):
+    db.execute('CREATE TABLE IF NOT EXISTS usage_daily(day TEXT,project_id TEXT,view_id TEXT,view_label TEXT,purpose TEXT,model TEXT,attempts INTEGER,successes INTEGER,errors INTEGER,input_items INTEGER,input_characters INTEGER,prompt_tokens INTEGER,output_tokens INTEGER,token_reports INTEGER,reported_usd REAL,price_reports INTEGER,elapsed_s REAL,PRIMARY KEY(day,project_id,view_id,purpose,model))')
+    db.execute('CREATE TABLE IF NOT EXISTS usage_index_jobs(job_id TEXT PRIMARY KEY,project_id TEXT,view_id TEXT,view_label TEXT,at REAL,kind TEXT,embedded_chunks INTEGER,reused_chunks INTEGER,unchanged_files INTEGER,embedded_characters INTEGER)')
+    db.execute('CREATE TABLE IF NOT EXISTS usage_imports(project_id TEXT PRIMARY KEY)')
+
+
+def _number(value):
+    return value if type(value) in (int,float) and math.isfinite(value) and value>=0 else None
+
+
+def record(*args,**kwargs):
+    try:_record(*args,**kwargs)
+    except Exception:pass  # Telemetria opcional não altera o resultado da chamada.
+
+
+def _record(path,body,response=None,headers=None,error=None,elapsed=0):
+    current=_CONTEXT.get()
+    if not current or path not in ('/v1/embeddings','/v1/rerank','/v1/chat/completions'):
+        return
+    body=body if isinstance(body,dict) else {}
+    response=response if isinstance(response,dict) else {}
+    usage=response.get('usage') or (response.get('meta') or {}).get('tokens') or {}
+    if not isinstance(usage,dict):usage={}
+    prompt=_number(usage.get('prompt_tokens',usage.get('input_tokens')))
+    output=_number(usage.get('completion_tokens',usage.get('output_tokens')))
+    if prompt is None and path=='/v1/embeddings':prompt=_number(usage.get('total_tokens'))
+    texts=body.get('input') if path.endswith('embeddings') else body.get('documents') if path.endswith('rerank') else []
+    if isinstance(texts,str):texts=[texts]
+    texts=texts if isinstance(texts,list) else []
+    characters=sum(len(t) for t in texts if isinstance(t,str))
+    if path.endswith('rerank'):characters+=len(body.get('query') or '')
+    if path.endswith('completions'):
+        characters=sum(len(m.get('content','')) for m in body.get('messages',[]) if isinstance(m,dict) and isinstance(m.get('content'),str))
+    cost=None
+    try:cost=_number(float((headers or {}).get('x-litellm-response-cost')))
+    except (TypeError,ValueError):pass
+    day=datetime.datetime.now(datetime.timezone.utc).date().isoformat()
+    values=(day,current['project_id'],current['view_id'],current['view_label'],current['purpose'],str(body.get('model','')),
+            1,int(error is None),int(error is not None),len(texts),characters,int(prompt or 0),int(output or 0),
+            int(prompt is not None or output is not None),cost or 0,int(cost is not None),round(elapsed,4))
+    # Telemetria opcional não pode derrubar a chamada do modelo.
+    try:
+        with project_store._LOCK,project_store._db() as db:
+            _tables(db)
+            fields=['attempts','successes','errors','input_items','input_characters','prompt_tokens','output_tokens','token_reports','reported_usd','price_reports','elapsed_s']
+            update=','.join(f'{name}={name}+excluded.{name}' for name in fields)
+            db.execute('INSERT INTO usage_daily VALUES('+','.join('?' for _ in values)+') ON CONFLICT(day,project_id,view_id,purpose,model) DO UPDATE SET '+update,values)
+            cutoff=(datetime.datetime.now(datetime.timezone.utc)-datetime.timedelta(days=366)).date().isoformat()
+            db.execute('DELETE FROM usage_daily WHERE day<?',(cutoff,))
+    except Exception:
+        pass
+
+
+def record_job(job_id,payload):
+    try:_record_job(job_id,payload)
+    except Exception:pass
+
+
+def _record_job(job_id,payload):
+    if payload.get('status')=='pending' or not isinstance(payload.get('stats'),dict):return
+    stats=payload['stats'];view=payload.get('view') or stats.get('view') or {'view_id':'legacy','label':'History without view'}
+    with project_store._LOCK,project_store._db() as db:
+        _tables(db)
+        db.execute('INSERT OR IGNORE INTO usage_index_jobs VALUES(?,?,?,?,?,?,?,?,?,?)',
+            (job_id,payload.get('project_id'),view.get('view_id','legacy'),view.get('label',''),payload.get('finished_at',time.time()),payload.get('kind',''),
+             stats.get('embedded_chunks',0),stats.get('reused_chunks',0),stats.get('unchanged',0),stats.get('embedded_characters',0)))
+        db.execute('DELETE FROM usage_index_jobs WHERE at<?',(time.time()-366*86400,))
+
+
+def summary(project_id,days=30,view_id=None):
+    if type(days) is not int or not 1<=days<=366:raise ValueError('Choose a period from 1 to 366 days.')
+    with project_store._LOCK,project_store._db() as db:
+        _tables(db)
+        imported=db.execute('SELECT 1 FROM usage_imports WHERE project_id=?',(project_id,)).fetchone()
+    if not imported:
+        for data in project_store.jobs(project_id,limit=project_store.MAX_JOBS):record_job(data['job_id'],data)
+        with project_store._LOCK,project_store._db() as db:
+            db.execute('INSERT OR IGNORE INTO usage_imports VALUES(?)',(project_id,))
+    cutoff=(datetime.datetime.now(datetime.timezone.utc)-datetime.timedelta(days=days-1)).date().isoformat()
+    args=[project_id,cutoff];where='project_id=? AND day>=?'
+    if view_id:where+=' AND view_id=?';args.append(view_id)
+    with project_store._LOCK,project_store._db() as db:
+        _tables(db);db.row_factory=__import__('sqlite3').Row
+        rows=[dict(r) for r in db.execute('SELECT * FROM usage_daily WHERE '+where+' ORDER BY day DESC,view_label,purpose',args)]
+        job_args=[project_id,datetime.datetime.fromisoformat(cutoff).replace(tzinfo=datetime.timezone.utc).timestamp()];job_where='project_id=? AND at>=?'
+        if view_id:job_where+=' AND view_id=?';job_args.append(view_id)
+        jobs=[dict(r) for r in db.execute('SELECT view_id,view_label,count(*) AS jobs,sum(embedded_chunks) AS embedded_chunks,sum(reused_chunks) AS reused_chunks,sum(unchanged_files) AS unchanged_files,sum(embedded_characters) AS embedded_characters FROM usage_index_jobs WHERE '+job_where+' GROUP BY view_id,view_label',job_args)]
+    totals={key:sum(row[key] for row in rows) for key in ('attempts','successes','errors','input_items','input_characters','prompt_tokens','output_tokens','token_reports','reported_usd','price_reports','elapsed_s')}
+    if not totals['price_reports']:totals['reported_usd']=None
+    if not totals['token_reports']:totals['prompt_tokens']=totals['output_tokens']=None
+    return {'days':days,'daily':rows,'indexing':jobs,'totals':totals,'currency':'USD',
+            'notes':['Calls and tokens are measured starting with this version. Earlier history only contains statistics that were already recorded.',
+                     'Monetary values appear only when reported by the model gateway; they are not an estimate of the full bill.',
+                     'Characters are not tokens. Cache reuse and unchanged files are counted separately.']}

package/version.py

@@ -0,0 +1,18 @@
+"""Single source of the Smart Tool version and of the User-Agent sent to public APIs."""
+import re
+
+VERSION = "0.9.1"
+_CONTACT_RE = re.compile(r"^(?:[^\s@()<>;]+@[^\s@()<>;]+\.[^\s@()<>;]+|https?://[^\s()<>;]+)$")
+
+
+def check_contact(value):
+    """Optional contact (e-mail or http(s) URL) that public APIs such as Wikimedia ask for in the User-Agent."""
+    value = str(value or "").strip()
+    if value and (len(value) > 200 or not _CONTACT_RE.match(value)):
+        raise ValueError("Contact must be an e-mail address or an http(s) URL, without spaces or parentheses.")
+    return value
+
+
+def user_agent(contact=""):
+    contact = check_contact(contact)
+    return f"SmartTool/{VERSION} (local MCP search tool{'; ' + contact if contact else ''})"

package/view_compare.py

@@ -0,0 +1,68 @@
+"""Compara snapshots guardados sem checkout, rede ou novos embeddings."""
+import contextlib
+import difflib
+from pathlib import Path
+
+import code_graph
+import index_inventory
+import indexer
+import project_storage
+
+
+def _files(path):
+    with contextlib.closing(indexer._readonly(path)) as db:
+        return dict(db.execute('SELECT path,hash FROM manifest'))
+
+
+def _text(path,file_path):
+    with contextlib.closing(indexer._readonly(path)) as db:
+        rows=db.execute('SELECT start_line,end_line,text FROM chunks WHERE path=? ORDER BY start_line,id',(file_path,)).fetchall()
+    return code_graph.reconstruct(rows)
+
+
+def compare(root,left_id,right_id,file_path=None,relations=True):
+    views=index_inventory.views(root);by_id={Path(v['path']).name:v for v in views}
+    left=by_id.get(left_id);right=by_id.get(right_id)
+    if not left or not right or left_id==right_id:raise ValueError('Choose two different views of the same project.')
+    stamps={v['path']:project_storage._stamp(v['path']) for v in (left,right)}
+    a,b=_files(left['path']),_files(right['path'])
+    added=set(b)-set(a);removed=set(a)-set(b)
+    old_hash={};new_hash={}
+    for name in removed:old_hash.setdefault(a[name],[]).append(name)
+    for name in added:new_hash.setdefault(b[name],[]).append(name)
+    renamed=[]
+    for digest,old in old_hash.items():
+        new=new_hash.get(digest,[])
+        if len(old)==len(new)==1:
+            renamed.append({'from':old[0],'to':new[0]});removed.remove(old[0]);added.remove(new[0])
+    changed=sorted(name for name in set(a)&set(b) if a[name]!=b[name])
+    result={'left':left,'right':right,'files':{'added':sorted(added),'removed':sorted(removed),'changed':changed,'renamed':renamed},
+            'unchanged':sum(a[name]==b[name] for name in set(a)&set(b)),
+            'notes':['Comparison of stored indexes. A missing item may come from a different scope, not only from a deletion in Git.'],
+            'read_only':True}
+    if file_path is not None:
+        if file_path not in a and file_path not in b:raise ValueError('File not found in these views.')
+        old,error_a=_text(left['path'],file_path) if file_path in a else ('',None)
+        new,error_b=_text(right['path'],file_path) if file_path in b else ('',None)
+        if error_a or error_b:result['diff_error']=error_a or error_b
+        else:
+            lines=list(difflib.unified_diff(old.splitlines(),new.splitlines(),fromfile=left['label']+'/'+file_path,tofile=right['label']+'/'+file_path,lineterm='',n=3))
+            output='\n'.join(lines[:1000]);result['diff']=output[:128000];result['diff_truncated']=len(lines)>1000 or len(output)>128000
+    if relations:
+        ga=code_graph.build(root,storage_id=left_id);gb=code_graph.build(root,storage_id=right_id)
+        def relations_of(graph):
+            nodes={s['id']:s for s in graph['symbols']}
+            def key(id):
+                n=nodes[id]
+                return n['path']+'::'+n['name']+(':'+str(n['start_line']) if n['name']=='callback' else '')
+            imports={(e['source'],e['target'],e.get('kind','import')) for e in graph['dependencies'] if e.get('target')}
+            calls={(key(e['source']),key(e['target']),e['kind']) for e in graph['calls']}
+            return imports,calls
+        ai,ac=relations_of(ga);bi,bc=relations_of(gb)
+        result['relations']={name:{'added':[list(x) for x in sorted(y-x)[:500]],'removed':[list(z) for z in sorted(x-y)[:500]],
+                                  'added_count':len(y-x),'removed_count':len(x-y)} for name,x,y in [('imports',ai,bi),('calls',ac,bc)]}
+        result['notes'].append('Named calls are compared by file/name; anonymous callbacks also use their location. Only resolved static relations are compared.')
+        result['analysis_partial']=ga['truncated'] or gb['truncated'] or bool(ga['diagnostics'] or gb['diagnostics'])
+    if any(project_storage._stamp(path)!=stamp for path,stamp in stamps.items()):
+        raise RuntimeError('A view was updated during the comparison. Compare again after the job finishes.')
+    return result