mirror of
https://github.com/Alkatrazz24/Funk-lab.git
synced 2026-07-09 01:24:42 +02:00
Alkatrazz
7d02efd9fa
- Ajout systemd timer hermes-auto-improve-daily.timer (22h00, Persistent=true) - Service oneshot : --all puis --daily-pr (TimeoutSec=7200 pour 28 fichiers) - auto-improve.py : flag --all qui bypass MAX_FILES et traite tout admin/ - trigger-server.py : timeout 600s → 7200s pour les runs --all via HTTP La rotation par batch (MAX_FILES=5) reste active pour les triggers n8n à la demande. Le workflow n8n 30-min doit être désactivé manuellement. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
370 lines
13 KiB
Python
370 lines
13 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
hermes-doc-worker — Hermes analyse admin/, écrit ses rapports dans
|
|
admin/hermes/builtin/ et push dans sa branche hermes/daily-work.
|
|
Ré-ingère tout admin/ dans Qdrant à chaque run.
|
|
|
|
Modes :
|
|
(défaut) : analyse un batch de fichiers, écrit rapport, push, ré-ingère
|
|
--daily-pr : crée une PR hermes/daily-work → main sur GitHub + retourne l'URL
|
|
--dry-run : analyse sans écrire ni push
|
|
"""
|
|
|
|
import argparse
|
|
import json
|
|
import os
|
|
import subprocess
|
|
import sys
|
|
from datetime import datetime
|
|
from pathlib import Path
|
|
|
|
REPO_DIR = Path("/srv/data/lab/Funk-lab")
|
|
BRANCH = "hermes/daily-work"
|
|
ADMIN_DIR = REPO_DIR / "admin"
|
|
BUILTIN_DIR = REPO_DIR / "admin" / "hermes" / "builtin"
|
|
RAG_DOCS = Path("/srv/data/rag/docs")
|
|
STATE_FILE = Path("/var/lib/hermes-auto-improve/state.json")
|
|
MAX_FILES = 5 # fichiers analysés par run
|
|
|
|
|
|
# ── Git helpers ──────────────────────────────────────────────────
|
|
|
|
def git(args: list) -> subprocess.CompletedProcess:
|
|
return subprocess.run(
|
|
["git", "-C", str(REPO_DIR)] + args,
|
|
capture_output=True, text=True
|
|
)
|
|
|
|
|
|
def git_sync():
|
|
"""S'assure qu'on est sur hermes/daily-work à jour."""
|
|
git(["config", "user.email", "hermes@funk.lab"])
|
|
git(["config", "user.name", "Hermes Bot"])
|
|
git(["fetch", "origin"])
|
|
r = git(["checkout", BRANCH])
|
|
if r.returncode != 0:
|
|
git(["checkout", "-b", BRANCH, f"origin/{BRANCH}"])
|
|
git(["pull", "--rebase", "origin", BRANCH])
|
|
|
|
|
|
# ── Hermes ───────────────────────────────────────────────────────
|
|
|
|
def ask_hermes(prompt: str) -> str:
|
|
safe = prompt.replace("'", "'\\''")
|
|
cmd = [
|
|
"sudo", "-i", "-u", "hermes", "bash", "-c",
|
|
f'HERMES_HOME=/srv/data/hermes hermes --profile funk-ai -z \'{safe}\''
|
|
]
|
|
r = subprocess.run(cmd, capture_output=True, text=True, timeout=180)
|
|
return r.stdout.strip()
|
|
|
|
|
|
# ── Analyse d'un fichier ─────────────────────────────────────────
|
|
|
|
def analyze_file(fpath: Path) -> dict:
|
|
rel = str(fpath.relative_to(REPO_DIR))
|
|
content = fpath.read_text(encoding="utf-8", errors="replace")
|
|
|
|
prompt = f"""Tu es l'agent de documentation du homelab Funk.
|
|
Analyse ce fichier de documentation et produis un rapport structuré.
|
|
|
|
Fichier : {rel}
|
|
---
|
|
{content[:4000]}
|
|
---
|
|
|
|
Réponds UNIQUEMENT en JSON valide (aucun texte avant ou après) :
|
|
{{
|
|
"fichier": "{rel}",
|
|
"statut": "ok" | "à_jour" | "obsolète" | "incomplet" | "erreur",
|
|
"score_qualité": 1-10,
|
|
"résumé": "une phrase sur l'état de ce document",
|
|
"problèmes": ["liste des problèmes concrets trouvés"],
|
|
"suggestions": ["liste des améliorations prioritaires"],
|
|
"état_réel": "ce que tu sais de l'état actuel de ce composant dans Funk (ou null)"
|
|
}}"""
|
|
|
|
raw = ask_hermes(prompt)
|
|
|
|
try:
|
|
start = raw.find("{")
|
|
end = raw.rfind("}") + 1
|
|
if start >= 0 and end > start:
|
|
return json.loads(raw[start:end])
|
|
except json.JSONDecodeError:
|
|
pass
|
|
|
|
return {
|
|
"fichier": rel,
|
|
"statut": "erreur_parse",
|
|
"score_qualité": 0,
|
|
"résumé": "Hermes n'a pas retourné de JSON valide",
|
|
"problèmes": [],
|
|
"suggestions": [],
|
|
"état_réel": None,
|
|
"_raw": raw[:300]
|
|
}
|
|
|
|
|
|
# ── Ré-ingestion Qdrant ──────────────────────────────────────────
|
|
|
|
def rag_ingest() -> str:
|
|
# Sync admin/ du clone vers /srv/data/rag/docs/
|
|
subprocess.run(
|
|
["rsync", "-a", "--delete",
|
|
str(ADMIN_DIR) + "/",
|
|
str(RAG_DOCS) + "/"],
|
|
check=True
|
|
)
|
|
r = subprocess.run(
|
|
["/usr/local/bin/rag-ingest"],
|
|
capture_output=True, text=True, timeout=300
|
|
)
|
|
return (r.stdout + r.stderr).strip()[-300:]
|
|
|
|
|
|
# ── Créer la PR GitHub ───────────────────────────────────────────
|
|
|
|
def _get_open_hermes_pr():
|
|
"""Retourne le numéro et l'URL de la PR Hermes ouverte, ou None."""
|
|
r = subprocess.run(
|
|
["gh", "pr", "list", "--repo", "Alkatrazz24/Funk-lab",
|
|
"--head", BRANCH, "--state", "open", "--json", "number,url"],
|
|
capture_output=True, text=True, timeout=30, cwd=str(REPO_DIR)
|
|
)
|
|
if r.returncode != 0:
|
|
return None
|
|
try:
|
|
prs = json.loads(r.stdout)
|
|
return prs[0] if prs else None
|
|
except (json.JSONDecodeError, IndexError):
|
|
return None
|
|
|
|
|
|
def create_github_pr(summary: str) -> dict:
|
|
today = datetime.now().strftime("%Y-%m-%d")
|
|
diff = git(["diff", "--stat", "origin/main...HEAD"])
|
|
stats = diff.stdout.strip() or "Aucune modification depuis main"
|
|
|
|
title = f"[Hermes] Rapport documentation — {today}"
|
|
body = f"""## Rapport quotidien Hermes — {today}
|
|
|
|
Ce Pull Request est créé automatiquement par Hermes à 22h.
|
|
|
|
### Ce que Hermes a fait aujourd'hui
|
|
{summary}
|
|
|
|
### Diff depuis main
|
|
```
|
|
{stats[:2000]}
|
|
```
|
|
|
|
### Comment reviewer
|
|
1. Vérifier les rapports dans `admin/hermes/builtin/`
|
|
2. Merger quand tout semble correct (squash merge configuré)
|
|
|
|
> Généré par `hermes-doc-worker` · branche `{BRANCH}`
|
|
"""
|
|
|
|
existing = _get_open_hermes_pr()
|
|
if existing:
|
|
# Met à jour le titre et le corps de la PR existante
|
|
subprocess.run(
|
|
["gh", "pr", "edit", str(existing["number"]),
|
|
"--repo", "Alkatrazz24/Funk-lab",
|
|
"--title", title,
|
|
"--body", body],
|
|
capture_output=True, text=True, timeout=30, cwd=str(REPO_DIR)
|
|
)
|
|
return {"html_url": existing["url"],
|
|
"number": existing["number"],
|
|
"title": title,
|
|
"updated": True}
|
|
|
|
r = subprocess.run(
|
|
["gh", "pr", "create",
|
|
"--title", title,
|
|
"--body", body,
|
|
"--head", BRANCH,
|
|
"--base", "main",
|
|
"--repo", "Alkatrazz24/Funk-lab"],
|
|
capture_output=True, text=True, timeout=30, cwd=str(REPO_DIR)
|
|
)
|
|
if r.returncode == 0:
|
|
pr_url = r.stdout.strip()
|
|
return {"html_url": pr_url, "title": title}
|
|
return {"error": r.stderr.strip() or "gh pr create a échoué"}
|
|
|
|
|
|
# ── Main ─────────────────────────────────────────────────────────
|
|
|
|
def load_state() -> dict:
|
|
if STATE_FILE.exists():
|
|
return json.loads(STATE_FILE.read_text())
|
|
return {"processed": [], "runs_today": 0, "last_run": None}
|
|
|
|
|
|
def save_state(state: dict):
|
|
STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
|
|
STATE_FILE.write_text(json.dumps(state, indent=2, ensure_ascii=False))
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument("--daily-pr", action="store_true", help="Créer PR GitHub + résumé journalier")
|
|
parser.add_argument("--dry-run", action="store_true", help="Analyser sans écrire ni push")
|
|
parser.add_argument("--all", action="store_true", help="Analyser tous les fichiers en une passe (ignore MAX_FILES)")
|
|
parser.add_argument("--subdir", default=None, help="Sous-dossier admin/ (ex: ia, k8s)")
|
|
args = parser.parse_args()
|
|
|
|
now = datetime.now()
|
|
run_ts = now.strftime("%Y-%m-%d_%H-%M")
|
|
today = now.strftime("%Y-%m-%d")
|
|
|
|
# ── Sync branche ─────────────────────────────────────────────
|
|
if not args.dry_run:
|
|
git_sync()
|
|
|
|
state = load_state()
|
|
|
|
# ── Mode PR journalier ────────────────────────────────────────
|
|
if args.daily_pr:
|
|
# Résumé des runs du jour
|
|
builtin_today = sorted(BUILTIN_DIR.glob(f"{today}_*.md")) if BUILTIN_DIR.exists() else []
|
|
summary_parts = []
|
|
for rpt in builtin_today[-5:]:
|
|
summary_parts.append(rpt.read_text()[:500])
|
|
daily_summary = "\n\n---\n\n".join(summary_parts) or "Aucun rapport généré aujourd'hui."
|
|
|
|
pr = create_github_pr(daily_summary)
|
|
result = {
|
|
"action": "daily_pr",
|
|
"pr_url": pr.get("html_url", ""),
|
|
"pr_number": pr.get("number", 0),
|
|
"pr_title": pr.get("title", ""),
|
|
"reports_today": len(builtin_today),
|
|
"error": pr.get("error", "")
|
|
}
|
|
print(json.dumps(result, indent=2, ensure_ascii=False))
|
|
return
|
|
|
|
# ── Sélection des fichiers à analyser ─────────────────────────
|
|
scan_root = ADMIN_DIR / args.subdir if args.subdir else ADMIN_DIR
|
|
all_md = [
|
|
f for f in sorted(scan_root.rglob("*.md"))
|
|
if "hermes/builtin" not in str(f) # ne pas analyser ses propres rapports
|
|
]
|
|
|
|
if args.all:
|
|
batch = all_md
|
|
state["processed"] = []
|
|
else:
|
|
# Rotation : reprend là où il s'est arrêté
|
|
todo = [f for f in all_md if str(f) not in state["processed"]]
|
|
if not todo:
|
|
state["processed"] = []
|
|
todo = all_md
|
|
batch = todo[:MAX_FILES]
|
|
results = []
|
|
|
|
# ── Analyse ───────────────────────────────────────────────────
|
|
for fpath in batch:
|
|
rel = str(fpath.relative_to(REPO_DIR))
|
|
print(f" → {rel}", flush=True)
|
|
|
|
analysis = analyze_file(fpath)
|
|
results.append(analysis)
|
|
state["processed"].append(str(fpath))
|
|
print(f" {analysis.get('statut','?')} — {analysis.get('score_qualité','?')}/10", flush=True)
|
|
|
|
save_state(state)
|
|
|
|
if not results:
|
|
print(json.dumps({"error": "aucun fichier à analyser"}))
|
|
return
|
|
|
|
# ── Écriture du rapport dans admin/hermes/builtin/ ────────────
|
|
BUILTIN_DIR.mkdir(parents=True, exist_ok=True)
|
|
report_path = BUILTIN_DIR / f"{run_ts}.md"
|
|
|
|
lines = [f"# Rapport Hermes — {run_ts}\n"]
|
|
lines += [f"> Branche : `{BRANCH}` · Fichiers analysés : {len(results)}\n"]
|
|
lines += ["\n---\n"]
|
|
|
|
ok_count = sum(1 for r in results if r.get("statut") in ("ok", "à_jour"))
|
|
bad_count = len(results) - ok_count
|
|
|
|
lines += [f"## Résumé\n",
|
|
f"- ✅ À jour : {ok_count}\n",
|
|
f"- ⚠️ À améliorer : {bad_count}\n\n"]
|
|
|
|
for r in results:
|
|
icon = "✅" if r.get("statut") in ("ok", "à_jour") else "⚠️"
|
|
lines.append(f"## {icon} `{r['fichier']}` — {r.get('score_qualité', '?')}/10\n\n")
|
|
lines.append(f"**Statut** : {r.get('statut', '?')} \n")
|
|
lines.append(f"**Résumé** : {r.get('résumé', '')} \n\n")
|
|
|
|
if r.get("problèmes"):
|
|
lines.append("**Problèmes :**\n")
|
|
for p in r["problèmes"]:
|
|
lines.append(f"- {p}\n")
|
|
lines.append("\n")
|
|
|
|
if r.get("suggestions"):
|
|
lines.append("**Suggestions :**\n")
|
|
for s in r["suggestions"]:
|
|
lines.append(f"- {s}\n")
|
|
lines.append("\n")
|
|
|
|
if r.get("état_réel"):
|
|
lines.append(f"**État réel connu de Hermes :** \n{r['état_réel']}\n\n")
|
|
|
|
lines.append("---\n\n")
|
|
|
|
if not args.dry_run:
|
|
report_path.write_text("".join(lines), encoding="utf-8")
|
|
print(f"\n✓ Rapport : {report_path.relative_to(REPO_DIR)}", flush=True)
|
|
|
|
# ── Commit + push ─────────────────────────────────────────────
|
|
if not args.dry_run:
|
|
git(["add", str(report_path.relative_to(REPO_DIR))])
|
|
|
|
if git(["diff", "--cached", "--quiet"]).returncode != 0:
|
|
git(["commit", "-m",
|
|
f"docs(hermes): rapport analyse {run_ts} — {len(results)} fichiers\n\n"
|
|
f"Analysés : {', '.join(r['fichier'].split('/')[-1] for r in results)}\n"
|
|
f"À améliorer : {bad_count}/{len(results)}\n\n"
|
|
"Co-Authored-By: Hermes <hermes@funk.lab>"])
|
|
git(["push", "origin", BRANCH])
|
|
print(f"✓ Push → {BRANCH}", flush=True)
|
|
|
|
# ── Ré-ingestion Qdrant (toujours) ────────────────────────
|
|
print("\n⏳ Qdrant re-ingest...", flush=True)
|
|
ingest_out = rag_ingest()
|
|
print(f" {ingest_out}", flush=True)
|
|
|
|
# ── Résumé JSON pour n8n ─────────────────────────────────────
|
|
summary = {
|
|
"run": run_ts,
|
|
"branch": BRANCH,
|
|
"analyzed": len(results),
|
|
"ok": ok_count,
|
|
"issues": bad_count,
|
|
"dry_run": args.dry_run,
|
|
"report": str(report_path.relative_to(REPO_DIR)) if not args.dry_run else None,
|
|
"details": [
|
|
{
|
|
"file": r["fichier"],
|
|
"statut": r.get("statut"),
|
|
"score": r.get("score_qualité"),
|
|
"résumé": r.get("résumé", ""),
|
|
}
|
|
for r in results
|
|
]
|
|
}
|
|
|
|
print("\n" + json.dumps(summary, indent=2, ensure_ascii=False))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|