sync SVN r18041

2026-08-23 11:08:56 +03:00
parent 79b08470be
commit 0027a28961
19 changed files with 369 additions and 592 deletions
--- a/docs/onboarding/PROMPT_cautare_vfp.md
+++ b/docs/onboarding/PROMPT_cautare_vfp.md
@@ -0,0 +1,139 @@
+# Prompt: căutare și editare în cod VFP (foxbin2prg) — reutilizabil în orice proiect Visual FoxPro
+
+**Prompt gata de copiat** pentru Claude Code (sau alt agent), care configurează și folosește
+sistemul `foxbin2prg` ca să poată **căuta** cod-sursă aflat **în interiorul fișierelor binare VFP**
+(`.vcx/.vct`, `.scx/.sct`, `.frx/.frt`, `.mnx/.mnt`, `.dbc/.dct`) într-un proiect nou — și, pentru
+`.vcx`/`.scx`, să poată și **modifica** acel cod direct pe text, cu write-back în binar
+(`txt2vcx.ps1`), fără trecere prin IDE-ul VFP.
+
+Unealta e partajată, la `D:\ROA\UTIL\foxbin2prg\` — nu se copiază per proiect. Doar spui agentului
+care e proiectul curent (folderul + fișierul `.pjx`).
+
+---
+
+## Cum se folosește
+
+1. Deschide proiectul VFP în Claude Code.
+2. Copiază blocul de mai jos în prompt.
+3. Înlocuiește cele **3 valori** marcate `<<...>>`:
+   - `<<RADACINA_PROIECT>>` = folderul rădăcină al proiectului (ex. `D:\ROA\ROAGEST`)
+   - `<<FISIER_PJX>>` = calea către `.pjx` (ex. `D:\ROA\ROAGEST\roagest.pjx`)
+   - `<<NUME_PROIECT>>` = etichetă scurtă pentru folderul de cache (ex. `roagest`)
+
+---
+
+## ▼▼▼ PROMPT DE COPIAT ▼▼▼
+
+```
+Acest proiect este o aplicație Visual FoxPro 9. O mare parte din cod (proceduri, metode,
+parametri) NU stă în fișiere .prg, ci în interiorul fișierelor binare VFP: librării de clase
+(.vcx+.vct), forme (.scx+.sct), rapoarte (.frx+.frt), meniuri (.mnx+.mnt). Un grep direct pe
+acestea nu e lizibil (sunt tabele DBF cu memo binar).
+
+Ca să poți căuta în acel cod, folosește unealta partajată foxbin2prg, care convertește binarele
+în reprezentarea lor TEXT (.vc2/.sc2/.fr2/.mn2/.dc2) într-un cache, și apoi caută în cache.
+
+PARAMETRII PROIECTULUI CURENT:
+- Rădăcină proiect: <<RADACINA_PROIECT>>
+- Fișier proiect (.pjx): <<FISIER_PJX>>
+- Cache text: D:\ROA\_vfp_textcache\<<NUME_PROIECT>>
+
+REGULA DE AUR: cache-ul text e sursa pentru CĂUTARE (toate tipurile de binar) și, DOAR pentru
+.vcx/.scx, și pentru EDITARE cu write-back (txt2vcx.ps1, vezi PAS 3). Pentru .frx/.mnx/.dbc
+textul rămâne doar pentru citire — modificările la ele se fac în IDE-ul VFP, pe binar.
+
+PAS 1 — populează cache-ul text (la începutul sesiunii, sau după ce s-a modificat ceva în IDE).
+Rulează în PowerShell (e incremental — sare peste ce e deja la zi):
+
+  & 'D:\ROA\UTIL\foxbin2prg\vcx2txt.ps1' -Project '<<FISIER_PJX>>' -ProjectRoot '<<RADACINA_PROIECT>>' -CacheRoot 'D:\ROA\_vfp_textcache\<<NUME_PROIECT>>'
+
+  (Folosește un -CacheRoot distinct per proiect ca să nu amesteci cache-urile. Implicit scriptul
+   convertește doar .vcx și .scx; pentru a include și rapoarte/meniuri adaugă: -Types vcx,scx,frx,mnx)
+
+Dacă scriptul se plânge că lipsește FoxBin2Prg.EXE, trebuie compilat o singură dată: deschide
+'D:\ROA\UTIL\foxbin2prg\foxbin2prg.pj2' în VFP 9 și Build > Build Executable. Anunță-mă să fac asta.
+
+PAS 2 — caută în cache cu unealta Grep (NU în binarele originale):
+
+  Grep pe folderul 'D:\ROA\_vfp_textcache\<<NUME_PROIECT>>' pentru numele de metodă/procedură/variabilă căutat.
+  Ex.: caută "PROCEDURE do_salvare" sau numele tabelei/cursorului implicat.
+
+PAS 2b — atribuie rezultatele clasei/metodei care le conține. Grep dă doar fișier:linie, iar
+într-un .vc2 antetul clasei poate fi cu mii de linii mai sus și ~2/3 din fișier e metadata:
+
+  & 'D:\ROA\UTIL\foxbin2prg\vfp_symbols.ps1' -CacheRoot 'D:\ROA\_vfp_textcache\<<NUME_PROIECT>>' -ProjectRoot '<<RADACINA_PROIECT>>' -Grep 'expresie' -CodeOnly
+
+  Alte moduri: -Where 'fisier.vc2:1234' (cine deține linia), -Find 'nume' (unde e DEFINIT, nu și
+  apelurile), -Class 'nume_clasa' (lanț de moștenire + metode cu intervalele de linii).
+  Indexul se reconstruiește singur din cache; rulează PAS 1 înainte.
+  OBLIGATORIU înainte de PAS 3: intervalul exact al metodei. Într-un .vc2 cu multe clase, Init,
+  Show, do_adauga există în aproape fiecare — fără interval editezi metoda din altă clasă.
+
+CONVERSIE PUNCTUALĂ (un fișier sau folder care NU e în proiect, ex. o librărie din COMUN):
+
+  & 'D:\ROA\UTIL\foxbin2prg\vcx2txt.ps1' -Source 'CALE\catre\librarie.vcx' -CacheRoot 'D:\ROA\_vfp_textcache\<<NUME_PROIECT>>'
+
+ALTE OPȚIUNI: -Force (reconvertește tot), -Clean (șterge cache-ul întâi).
+
+PAS 3 — modificare de cod în .vcx/.scx (flux write-back pe text). Ordinea e obligatorie:
+
+  a. Investighează pe cache. Ordinea write-back/aprobare/commit urmează `reguli_lucru.md`
+     (write-back-ul și testele se fac imediat, fără să aștepți răspunsul; aprobarea
+     condiționează COMMIT-ul, nu write-back-ul).
+  b. Refresh cache (PAS 1) dacă a rulat vreo sesiune de IDE de la ultimul refresh (staleness-ul
+     se verifică pe mtime și txt2vcx refuză corect scrierea peste modificări nevăzute). Înainte
+     de write-back închide COMPLET VFP IDE și exe-ul aplicației — procesele reziduale țin lock
+     pe binare.
+  c. Editează .vc2/.sc2 BYTE-SAFE: formatul e position-sensitive (nu reformata/reflow linii),
+     proprietățile sunt alfabetizate (una nouă se inserează la locul ei alfabetic). Headerul
+     CPID="1252" poate minți despre codepage-ul real al diacriticelor — citește/scrie fișierul
+     ca bytes (PowerShell), conținutul NOU doar ASCII; nu folosi unelte care re-encodează.
+  d. Write-back:
+
+     & 'D:\ROA\UTIL\foxbin2prg\txt2vcx.ps1' -TextFile 'D:\ROA\_vfp_textcache\<<NUME_PROIECT>>\Clase\lib.vc2' -ProjectRoot '<<RADACINA_PROIECT>>' -CacheRoot 'D:\ROA\_vfp_textcache\<<NUME_PROIECT>>'
+
+     Regenerează + compilează binarul în staging, verifică fidelitatea (roundtrip byte-identic
+     față de textul editat) și abia apoi copiază binarul în proiect; la orice eșec proiectul
+     rămâne neatins. Ținte sub COMUN\ cer flag-ul -AllowComun ȘI aprobare explicită — o
+     modificare acolo afectează toate aplicațiile ROA.
+  e. Diff lizibil pentru review: extrage binarul vechi din git (git show HEAD:cale > temp, atât
+     .vcx cât și .vct), regenerează-i textul cu vcx2txt.ps1 -Source într-un folder temporar și
+     compară cu cache-ul editat: git diff --no-index. COMMIT DOAR după ce omul confirmă pe diff
+     și testează în IDE.
+
+EXCEPȚII: pentru .mnx (GENMENU) și .frx (fragile la round-trip) nu există write-back — scrie
+propunerea de modificare într-un fișier docs/propuneri_<subiect>.md (cod + unde se inserează),
+iar aplicarea se face manual în IDE-ul VFP.
+
+FLUX TIPIC: la prima sesiune rulează PAS 1 o dată, apoi caută cu Grep în cache (PAS 2). La
+sesiunile următoare rescrie doar ce s-a schimbat. Când citești codul unei metode, dă referințe
+fișier:linie din cache.
+```
+
+## ▲▲▲ SFÂRȘIT PROMPT ▲▲▲
+
+---
+
+## Note pentru adaptare
+
+- `<<NUME_PROIECT>>` poate fi orice etichetă scurtă (ex. `roagest`), unică per proiect (numele
+  folderului de cache).
+- Ține cache-ul în `D:\ROA\_vfp_textcache\`, adică **în afara** folderului `foxbin2prg`. Motiv:
+  `ReCreate_FoxBin2Prg.prg` face `Prg2Bin` recursiv pe tot folderul tool-ului și ar reconverti
+  `.??2`-urile din orice cache aflat sub el înapoi în binare parazitare.
+- Scriptul citește lista de fișiere direct din `.pjx`, deci convertește doar ce folosește efectiv
+  proiectul (rapid), nu tot `COMUN\`.
+- Cache-ul e regenerabil, în afara arborelui de versionare al proiectului (și al clonei
+  foxbin2prg) — poate fi șters oricând.
+- Conversia NU necesită IDE-ul VFP deschis (folosește `FoxBin2Prg.EXE` compilat).
+- Fără backup-uri `.bak` lângă binarele din proiect — git e mecanismul de restore; `txt2vcx.ps1`
+  ține o copie de siguranță doar în folderul temp al rulării.
+- Editările de volum se pot delega la subagenți (Sonnet, în background) — sesiunea principală
+  orchestrează, verifică diff/fidelity și intervine doar la deblocări și decizii.
+- Detalii complete despre write-back (guard-uri, encoding, dialoguri VFP modale la text corupt,
+  testul de regresie `test_roundtrip.ps1`): `D:\ROA\UTIL\foxbin2prg\CLAUDE.md`.
+- Exemplu funcțional, rodat pe ROAGEST: `D:\ROA\ROAGEST\docs\flux-editare-vfp-text.md` și
+  `D:\ROA\ROAGEST\docs\CLAUDE.md` (modul de lucru complet, cu review pe diff înainte de commit).
+- Ghid complet doar-căutare (varianta ROAACNPRO, cu exemple): `D:\ROA\ROAACNPRO\docs\cautare_vcx_vct.md`.
+- Tabel corespondență binar → text: `.vcx`→`.vc2`, `.scx`→`.sc2`, `.frx`→`.fr2`, `.mnx`→`.mn2`,
+  `.dbc`→`.dc2`, `.lbx`→`.lb2`.
--- a/docs/onboarding/inrolare-proiect-git-text.md
+++ b/docs/onboarding/inrolare-proiect-git-text.md
@@ -0,0 +1,130 @@
+# Inrolarea unui proiect ROA (Visual FoxPro) in fluxul git-text FoxBin2Prg
+
+Pasi pentru o sesiune Claude Code care inroleaza un proiect ROA in fluxul in care git urmareste
+DOAR versiunile text FoxBin2Prg (.vc2/.sc2/.fr2/.mn2/.lb2/.pj2/.dc2/.db2) generate in arbore,
+langa binarele VFP. SVN ramane sursa de adevar si nu se atinge (niciun svn commit fara acordul
+explicit al utilizatorului).
+
+Proiecte deja inrolate: ROACONT, ROAGEST, ROAAUTO, ROAIMOB, ROAACNPRO, ROAFACTURARE + COMUN
+(romfast/comun.git). Modelul de referinta e ROACONT.
+
+## Reguli pentru sesiunea care executa
+
+- Foloseste EXCLUSIV PowerShell (NU Bash — bash.exe crapa pe aceste masini si lasa stackdump-uri).
+- NU face niciun `svn commit`. NU modifica binarele VFP. La final binarele trebuie sa fie
+  byte-identice (`svn status`: niciun binar M).
+- Rularile de conversie dureaza zeci de minute pe proiecte mari: sunt incrementale, daca expira
+  timeout-ul tool-ului se reiau pana la capat.
+- Nu rula doua conversii git_sync in paralel pe acelasi arbore.
+
+## Preconditii
+
+1. Tooling partajat in `D:\ROA\UTIL\foxbin2prg\`: `git_sync.ps1`, `vfp_filemap.ps1`,
+   `txt2vcx.ps1`, `test_git_sync.ps1`, `test_roundtrip.ps1`. Citeste-le inainte (macar help-ul
+   din git_sync.ps1). `roa_sync.ps1` (+ `test_roa_sync.ps1`) traieste in `COMUN\scripts\` si
+   vine singur cu svn update; in foxbin2prg a ramas doar un stub de compatibilitate.
+2. Proiectul e working copy SVN valid (`svn info D:\ROA\<PROIECT>`), cu `COMUN\` inauntru
+   (external SVN).
+3. Repo-ul gitea exista: `git ls-remote git@gitea.romfast.ro:romfast/<proiect>.git`. Daca nu
+   exista, cere utilizatorului sa-l creeze din interfata gitea (NU crea repo-uri prin API din
+   proprie initiativa).
+4. SVN global-ignores pe masina contine `*.vc2 *.sc2 *.fr2 *.mn2 *.lb2 *.pj2 *.dc2 *.db2
+   *.dbf.cfg` (in `%APPDATA%\Subversion\config`, sectiunea [miscellany]). Fara asta, textele apar
+   ca `?` in svn status si risca svn add accidental.
+5. Daca proiectul ARE deja git cu istoric si urmeaza reset: confirmarea utilizatorului ca nu
+   exista clone active pe alte masini (force-push rescrie istoria).
+
+## Pasi
+
+### 1. Inventar prealabil (inainte de orice stergere)
+
+- Exista `.git`? Noteaza `git remote -v` si branch-ul. Exista `COMUN\.git`?
+- `git ls-files *.dbf` (daca exista repo vechi): tabelele urmarite azi ca binare sunt candidate
+  la conversie .db2 (cerinta: tot ce e convertibil trece pe text).
+
+### 2. Conversia completa
+
+```powershell
+& D:\ROA\UTIL\foxbin2prg\git_sync.ps1 -ProjectRoot D:\ROA\<PROIECT>
+```
+
+- DbfList implicit acopera `Locale\locale*.dbf`, `Help\*.dbf`, `DATE\Optiuni_*.dbf` si toate
+  dbf-urile COMUN. Tabele de configurare specifice proiectului se adauga cu `-DbfList` explicit
+  (ATENTIE: parametrii array NU se pot pasa prin `powershell -File` — invoca scriptul in-process
+  cu `&`, altfel array-ul se colapseaza). Tabele operationale mari nu se adauga; un .db2 peste
+  5 MB ramane binar.
+- Esecuri de conversie — se investigheaza fiecare:
+  - meniuri pre-VFP9 ("NOT in VFP 9 Format"): raman binare, cu exceptii negate `!` in
+    .gitignore; intra in flux doar dupa re-salvare in VFP9 (MODIFY MENU -> save);
+  - clase FFC/third-party cu roundtrip fals-negativ (#INCLUDE lipsa in staging izolat, ex. cele
+    6 din COMUN deja scutite implicit): se adauga la `-RoundtripExempt`;
+  - alte esecuri reale: fisierul ramane binar urmarit (exceptie `!`) si se raporteaza.
+- Regula: nu se trece mai departe cu esecuri neexplicate (exit code nenul).
+
+### 3. .gitignore si .gitattributes
+
+- Copiaza `D:\ROA\ROACONT\.gitignore` ca model si adapteaza: sectiunea machine-local (exe-ul
+  proiectului, <proiect>_ref.DBF/FPT/CDX, FOXUSER, .ini/.ARM, log-uri) si sectiunea dbf: fiecare
+  .dbf care are .db2 se ignora INDIVIDUAL (plus .fpt-ul lui). NU ignora: `*.??2`, `*.dbf.cfg`,
+  grafica (bmp/ico/jpg/png), ocx, tmpl.
+- `.gitattributes` cu `* -text` (SVN ramane autoritatea EOL; git nu normalizeaza).
+
+### 4. Init/reset repo proiect
+
+```powershell
+# doar la reset: Remove-Item -Recurse -Force D:\ROA\<PROIECT>\.git
+git -C D:\ROA\<PROIECT> init -b main
+git -C D:\ROA\<PROIECT> remote add origin git@gitea.romfast.ro:romfast/<proiect>.git
+git -C D:\ROA\<PROIECT> add -A
+```
+
+VERIFICARE OBLIGATORIE inainte de commit (`git ls-files` pe staged):
+- 0 binare convertibile urmarite (vcx/vct/scx/sct/frx/frt/mnx/mnt/lbx/lbt/pjx/pjt/dbc/dct/cdx/dcx),
+  cu exceptia celor cu `!` justificate;
+- textele .??2 prezente; 0 fisiere din COMUN/ (are repo-ul lui).
+
+Commit: `Initial: flux text FoxBin2Prg (git urmareste .??2 in-arbore, binarele VFP git-ignored)`
+ linia Co-Authored-By a sesiunii. Push: `git push -u origin main` (`--force` doar la reset).
+
+### 5. Clona COMUN a proiectului
+
+```powershell
+# daca exista .git vechi: Remove-Item -Recurse -Force D:\ROA\<PROIECT>\COMUN\.git
+git -C D:\ROA\<PROIECT>\COMUN init -b main
+git -C D:\ROA\<PROIECT>\COMUN remote add origin git@gitea.romfast.ro:romfast/comun.git
+git -C D:\ROA\<PROIECT>\COMUN fetch origin
+git -C D:\ROA\<PROIECT>\COMUN reset origin/main          # mixed: pastreaza discul
+git -C D:\ROA\<PROIECT>\COMUN checkout origin/main -- .gitignore
+```
+
+Diferentele ramase in `git status` = revizii SVN diferite ale clonei (normal). NU comite nimic in
+comun.git dintr-o clona decalata — comun se comite doar din clona in care s-a lucrat efectiv,
+dupa svn update.
+
+### 6. roa_sync.bat
+
+Copiaza `D:\ROA\ROAFACTURARE\roa_sync.bat` in radacina proiectului (generic, foloseste `%~dp0` si
+cheama `COMUN\scripts\roa_sync.ps1`) si include-l in commit. Utilizatorul il ruleaza la inceput de
+sesiune: svn update -> git_sync -> commit "sync SVN rN" pe main (proiect + COMUN) -> reconciliere
+cu origin + push (doar commit-uri de sync) -> inchide branch-urile claude/* cu diff gol.
+
+### 7. Verificari finale
+
+- Acoperire: fiecare binar convertibil din arbore (inclusiv COMUN) are text .??2 langa el
+  (exceptiile `!` enumerate si justificate).
+- `svn status`: niciun binar modificat, niciun .??2 adaugat in SVN.
+- `git ls-remote origin main` = HEAD-ul local.
+- Raport final: numar texte per tip, esecuri/scutiri, commit hash, push status.
+
+## Note operationale
+
+- Dialogurile modale FoxBin2Prg sunt suprimate de scripturi printr-un `foxbin2prg.cfg` cu
+  `DontShowErrors: 1` scris per-director de staging (cfg-ul global de langa exe NU e fiabil).
+  Daca utilizatorul vede totusi un MessageBox, e un dialog nativ VFP — watchdog-ul din
+  Invoke-FoxBin2PrgSafe il omoara la timeout.
+- Tabelele legate de un DBC au nevoie de .dbc/.dct/.dcx si .cdx langa ele la conversie
+  (git_sync face asta automat in staging).
+- `DBF_Conversion_Support: 4` (scris de git_sync in cfg-ul de staging) exporta DATELE in .db2, nu
+  doar structura.
+- Fisierele doar-git (docs, .bat, .gitignore) se comit separat, inainte de sync-ul "sync SVN rN",
+  altfel nimeresc in commit-ul de sincronizare.
--- a/docs/onboarding/prompt_project_insights_docs.md
+++ b/docs/onboarding/prompt_project_insights_docs.md
@@ -0,0 +1,19 @@
+# Prompt: seteaza conventia docs/ (insight-uri de proiect) intr-un proiect ROA
+
+Template partajat intre proiectele ROA* (similar cu `changelog_template.txt`). Copiaza blocul de mai jos (adaptat, daca e nevoie) intr-o sesiune Claude Code din radacina oricarui proiect ROA* pentru a initializa aceeasi conventie.
+
+---
+
+In acest proiect vreau sa creezi un director `docs/` cu documentatie tehnica concisa, minimalista, descoperita in timp ce lucrezi la sarcini reale (nu documentatie generica, nu ce e deja evident din cod).
+
+Cerinte:
+
+1. Creeaza `docs/README.md` — index cu lista fisierelor din `docs/` si o regula scurta: se adauga/actualizeaza o notita ori de cate ori descoperi ceva nou si ne-evident despre structura proiectului (flux ascuns, capcana, conventie, procedura/pachet cheie, tabel relevant) in timpul rezolvarii unei sarcini. Nu re-documenta ce oricine ar afla citind codul in 30 de secunde.
+2. Organizeaza notitele in fisiere separate pe subiect, nu un singur fisier uriaș — ex: `flux-<nume-flux>.md`, `pachet-<nume-pachet>.md`, `tabele.md`.
+3. In `CLAUDE.md` (la final), adauga o sectiune "Project insights (docs/)" care:
+   - trimite spre `docs/README.md`
+   - imi cere sa iti ofer proactiv actualizarea `docs/` ori de cate ori descoperi un insight ne-evident, fara sa astept sa fiu intrebat
+4. Daca `docs/` sau o sectiune similara in `CLAUDE.md` exista deja, nu duplica — extinde ce exista.
+5. Nu inventa continut acum daca nu am rezolvat inca o problema concreta in acest proiect — doar pregateste structura (README + sectiunea din CLAUDE.md). Prima notita de continut se scrie cand rezolvam ceva impreuna.
+
+Intreaba-ma doar daca trebuie sa alegi intre variante (ex. denumirea directorului); altfel foloseste `docs/` ca implicit.