fidelizare-integrate 0.2.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fidelizare-integrate",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Asistent de integrare Fidelizare pentru softuri de gestiune si case de marcat. Scaneaza codul, gaseste locul potrivit si propune integrarea API-ului, in siguranta.",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -52,7 +52,7 @@ async function main() {
     rawKey = 's2s_beta_demo_0000000000000000000000000000';
     note('Cheie API demo incarcata in seif (nu apare niciodata in cod sau in agent).', C.ink);
   } else {
-    rawKey = await ask('Lipeste cheia ta API Fidelizare:');
+    rawKey = val('--key') || process.env.FIDELIZARE_API_KEY || (await ask('Lipeste cheia ta API Fidelizare:'));
     if (!rawKey) { note('Fara cheie API. Inchidem.', C.amber); rl.close(); return; }
   }
   const keyRef = vaultPut(rawKey, 'Fidelizare API key');
@@ -90,24 +90,17 @@ async function main() {
   // 5a. Agentic tool-loop (real coding agent): the model uses tools and
   // applies the integration itself, each write gated by confirmation.
   if (has('--agent') && (process.env.OPENROUTER_API_KEY || process.env.FIDELIZARE_LLM_KEY)) {
-    heading('Agent de integrare');
-    if (!git.isRepo) note('• Nu e repo git. Fac copii .bak la fiecare modificare.', C.amber);
-    else if (!git.clean) note('• Repo git cu modificari necomise (le poti anula cu git checkout).', C.amber);
-    else note('• Repo git curat. Orice modificare e reversibila.', C.green);
-    note('• Agent: ' + bold(paint(val('--model') || 'Opus 4.8', C.red)) +
-      paint('  tool-uri: list/read/grep/create/insert/check. Fiecare scriere cere confirmare.', C.dim));
-    out('\n');
+    out('  ' + paint('Agent ', C.ink) + bold(paint(val('--model') || 'Opus 4.8', C.red)) +
+      paint('  ·  scrierile cer confirmare (y / a / N)', C.dim) + '\n\n');
     const r = await runAgentLoop({
       stack: det.stack, rootDir: root, files,
-      askRaw: ask, auto: AUTO, model: val('--model'), log: out,
+      askRaw: ask, auto: AUTO, model: val('--model'),
+      guideUrl: val('--guide') || process.env.FIDELIZARE_GUIDE_URL,
     });
     if (r.ok) {
       writeEnv(root, vaultResolve(keyRef));
-      rule(); heading('Gata');
-      note('Rezumat agent: ' + r.summary, C.white);
-      note('Fisiere atinse: ' + (r.changes.join(', ') || '—'), C.ink);
-      note('Configuratie: .env (cheia API, nu in cod). Anulare: fisiere .bak / git checkout.', C.dim);
-      note('Test: scaneaza un cod de fidelitate (ex 12333) si verifica punctele.', C.ink);
+      out('\n  ' + paint('✓', C.green) + '  ' + paint(r.summary.split('\n')[0].slice(0, 88), C.white) + '\n');
+      note((r.changes.join(', ') || '—') + paint('   ·  cheia in .env, anulare: git checkout', C.dim), C.ink);
       out('\n  ' + paint('Integrare pregatita.', C.green) + ' ' + paint('Fidelizare', C.red) + '\n\n');
       rl.close();
       return;

package/src/core/agent-loop.js

@@ -8,28 +8,38 @@
 // Runs on OpenRouter (function-calling), default Opus 4.8.
 import { readFileSync, existsSync } from 'fs';
 import { relative, join, resolve, extname } from 'path';
-import { execFileSync } from 'child_process';
+import { execFileSync, execSync } from 'child_process';
 import { redact } from './vault.js';
 import { safeCreateFile, safeInsert, insideRoot } from './apply.js';
 import { C, paint, out } from '../ui/ansi.js';
+import { thinking, toolLine } from '../ui/anim.js';
 
 const URL = 'https://openrouter.ai/api/v1/chat/completions';
 const DEFAULT_MODEL = 'anthropic/claude-opus-4.8';
-const MAX_STEPS = 24;
+const DEFAULT_GUIDE = 'https://mcp.fidelizare.ro/assets/api-guide.md';
+const MAX_STEPS = 30;
+// Only test/compile runners may be executed via run_test (no arbitrary shell).
+const ALLOW_TEST = /^(node |npm (test|run |ci\b)|npx (jest|mocha|vitest)|python3? |pytest|php |phpunit|ruby |rspec|go (test|build|run)|dotnet (test|build)|javac |mvn )/i;
 
-const SYSTEM = `Esti un agent de integrare care lucreaza DIRECT in codul unui soft de
-gestiune / casa de marcat, prin apeluri de tool. Scopul: integreaza API-ul
-Fidelizare astfel incat, cand scannerul citeste un cod de fidelitate (nu un
-produs), softul sa apeleze POST https://fidelizare.ro/api/integration/s2s/submitReceipt.
+const SYSTEM = `Esti un agent de integrare care lucreaza DIRECT in codul unui soft de gestiune
+/ casa de marcat, prin apeluri de tool, ca un coding agent autonom.
 
-Lucreaza in pasi: foloseste tool-urile pentru a citi codul (list_files, read_file,
-grep), apoi creeaza un fisier helper (create_file) care apeleaza API-ul folosind
-cheia din variabila de mediu FIDELIZARE_API_KEY (NICIODATA cheie in cod), intr-un
-try/catch ce nu blocheaza vanzarea; apoi insereaza apelul (insert_code) exact la
-ramura unde se detecteaza cardul, plus importul. Verifica cu check_syntax. La final
-apeleaza finish.
+Pasi:
+1. Citeste documentatia API cu web_fetch pe URL-ul primit, ca sa stii endpoint,
+   antet, corp si reguli.
+2. Orienteaza-te SINGUR in cod (list_files, read_file, grep) si gaseste fisierul si
+   linia unde codul detecteaza un cod de fidelitate (cod scanat care NU e produs).
+3. Creeaza un helper (create_file) care apeleaza API-ul conform documentatiei, cu
+   cheia din variabila de mediu FIDELIZARE_API_KEY (NICIODATA in cod), in try/catch
+   ce nu blocheaza vanzarea.
+4. Insereaza apelul (insert_code) exact pe acea ramura, plus import-ul necesar.
+5. Scrie un test cu mock (create_file) care verifica: apelul se face cu fidelity_card
+   = codul scanat; o eroare de retea NU arunca si NU blocheaza fluxul. Ruleaza-l cu
+   run_test pana trece.
+6. Verifica sintaxa (check_syntax) si apeleaza finish cu un rezumat scurt.
 
-Reguli: modificari minime, fara refactor; pastreaza stilul; nu inventa cai de fisier.`;
+Reguli: modificari minime, fara refactor; pastreaza stilul si limbajul proiectului;
+nu scrie chei in cod; nu inventa cai de fisier.`;
 
 const TOOLS = [
   { type: 'function', function: { name: 'list_files', description: 'Listeaza fisierele sursa din proiect.', parameters: { type: 'object', properties: {} } } },
@@ -37,14 +47,17 @@ const TOOLS = [
   { type: 'function', function: { name: 'grep', description: 'Cauta un pattern (regex) in tot codul.', parameters: { type: 'object', properties: { pattern: { type: 'string' } }, required: ['pattern'] } } },
   { type: 'function', function: { name: 'create_file', description: 'Creeaza un fisier nou (gated: confirmare + backup).', parameters: { type: 'object', properties: { path: { type: 'string' }, content: { type: 'string' } }, required: ['path', 'content'] } } },
   { type: 'function', function: { name: 'insert_code', description: 'Insereaza linii dupa atLine (gated: diff + confirmare + backup).', parameters: { type: 'object', properties: { path: { type: 'string' }, atLine: { type: 'number' }, lines: { type: 'array', items: { type: 'string' } }, reason: { type: 'string' } }, required: ['path', 'atLine', 'lines'] } } },
+  { type: 'function', function: { name: 'web_fetch', description: 'Descarca un document de pe web (https), ex. documentatia API.', parameters: { type: 'object', properties: { url: { type: 'string' } }, required: ['url'] } } },
+  { type: 'function', function: { name: 'run_test', description: 'Ruleaza o comanda de test/compilare in proiect (gated, doar runnere cunoscute).', parameters: { type: 'object', properties: { command: { type: 'string' } }, required: ['command'] } } },
   { type: 'function', function: { name: 'check_syntax', description: 'Verifica sintaxa unui fisier (doar Node).', parameters: { type: 'object', properties: { path: { type: 'string' } }, required: ['path'] } } },
   { type: 'function', function: { name: 'finish', description: 'Termina integrarea.', parameters: { type: 'object', properties: { summary: { type: 'string' } }, required: ['summary'] } } },
 ];
 
-export async function runAgentLoop({ stack, rootDir, files, askRaw, auto, model, log }) {
+export async function runAgentLoop({ stack, rootDir, files, askRaw, auto, model, guideUrl }) {
   const key = process.env.OPENROUTER_API_KEY || process.env.FIDELIZARE_LLM_KEY;
   if (!key) return { ok: false, reason: 'no_key' };
   const usedModel = model || DEFAULT_MODEL;
+  const guide = guideUrl || DEFAULT_GUIDE;
 
   const rel = (p) => relative(rootDir, p);
   const abs = (p) => resolve(join(rootDir, p));
@@ -53,7 +66,7 @@ export async function runAgentLoop({ stack, rootDir, files, askRaw, auto, model,
 
   // Permission harness (opencode-style): read/grep/list/check are auto-allowed;
   // writes ask, with an "always" reply that approves that action for the run.
-  const policy = { create_file: 'ask', insert_code: 'ask' };
+  const policy = { create_file: 'ask', insert_code: 'ask', run_test: 'ask' };
   const permit = async (action, label) => {
     if (auto || policy[action] === 'allow') return true;
     const a = (await askRaw(label + ' [y=da / a=mereu / N=nu]')).toLowerCase();
@@ -82,23 +95,36 @@ export async function runAgentLoop({ stack, rootDir, files, askRaw, auto, model,
     create_file: async ({ path, content }) => {
       const a = abs(path);
       if (!insideRoot(rootDir, a)) return 'REFUZAT: in afara proiectului';
-      log('\n  ' + paint('＋ fisier nou  ', C.green) + paint(rel(a), C.white) + '\n');
-      content.split('\n').slice(0, 12).forEach((l) => log('    ' + paint('+ ', C.green) + paint(redact(l), C.ink) + '\n'));
-      if (!(await permit('create_file', 'Creez acest fisier?'))) return 'REFUZAT de utilizator';
+      if (!(await permit('create_file', '   ↳ scriu ' + rel(a) + '?'))) return 'REFUZAT de utilizator';
       const r = safeCreateFile(rootDir, a, content);
       changes.push(rel(a)); return 'OK creat (' + r.lines + ' linii)';
     },
-    insert_code: async ({ path, atLine, lines, reason }) => {
+    insert_code: async ({ path, atLine, lines }) => {
       const a = abs(path);
       if (!insideRoot(rootDir, a) || !existsSync(a)) return 'REFUZAT: fisier inexistent';
-      const src = readFileSync(a, 'utf8').split('\n');
-      log('\n  ' + paint('✎ ' + rel(a) + ' @ linia ' + atLine, C.amber) + (reason ? paint('  ' + reason, C.dim) : '') + '\n');
-      for (let i = Math.max(0, atLine - 2); i < atLine; i++) log('    ' + paint('  ' + (src[i] ?? ''), C.dim) + '\n');
-      lines.forEach((l) => log('    ' + paint('+ ' + l, C.green) + '\n'));
-      if (!(await permit('insert_code', 'Aplic aceasta modificare?'))) return 'REFUZAT de utilizator';
+      if (!(await permit('insert_code', '   ↳ modific ' + rel(a) + ' @' + atLine + '?'))) return 'REFUZAT de utilizator';
       const r = safeInsert(rootDir, a, atLine, lines);
       changes.push(rel(a)); return 'OK inserat ' + r.added + ' linii dupa ' + r.atLine;
     },
+    web_fetch: async ({ url }) => {
+      if (!/^https:\/\//i.test(url || '')) return 'doar URL https';
+      try {
+        const r = await fetch(url, { signal: AbortSignal.timeout(15_000) });
+        if (!r.ok) return 'HTTP ' + r.status;
+        return redact(await r.text()).slice(0, 9000);
+      } catch (e) { return 'eroare fetch: ' + (e?.message || e); }
+    },
+    run_test: async ({ command }) => {
+      const cmd = String(command || '').trim();
+      if (!ALLOW_TEST.test(cmd)) return 'comanda nepermisa (doar runnere de test/compilare): ' + cmd;
+      if (!(await permit('run_test', '   ↳ rulez `' + cmd + '`?'))) return 'REFUZAT de utilizator';
+      try {
+        const o = execSync(cmd, { cwd: rootDir, timeout: 90_000, stdio: 'pipe' });
+        return 'OK\n' + o.toString().slice(0, 1500);
+      } catch (e) {
+        return 'ESUAT (cod ' + (e.status ?? '?') + ')\n' + (((e.stdout?.toString() || '') + (e.stderr?.toString() || '')).slice(0, 1500));
+      }
+    },
     check_syntax: ({ path }) => {
       const a = abs(path);
       if (!existsSync(a)) return 'fisier inexistent';
@@ -111,10 +137,21 @@ export async function runAgentLoop({ stack, rootDir, files, askRaw, auto, model,
 
   const messages = [
     { role: 'system', content: SYSTEM },
-    { role: 'user', content: `Stack: ${stack}. Proiect cu ${files.length} fisiere sursa. Integreaza API-ul Fidelizare. Incepe prin a te orienta in cod.` },
+    { role: 'user', content: `Stack: ${stack}. Documentatie API: ${guide}. Proiect cu ${files.length} fisiere sursa. Incepe cu web_fetch pe documentatie, apoi orienteaza-te in cod, integreaza si scrie + ruleaza un test cu mock.` },
   ];
 
+  const NAMES = { list_files: 'List', read_file: 'Read', grep: 'Grep', create_file: 'Write', insert_code: 'Edit', web_fetch: 'Fetch', run_test: 'Test', check_syntax: 'Check', finish: 'Done' };
+  const brief = (name, a) => {
+    if (name === 'grep') return a.pattern ? '"' + a.pattern + '"' : '';
+    if (name === 'web_fetch') return a.url || '';
+    if (name === 'run_test') return a.command ? '`' + a.command + '`' : '';
+    if (name === 'insert_code') return (a.path ? rel(abs(a.path)) : '') + (a.atLine ? ' @' + a.atLine : '');
+    if (a.path) return rel(abs(a.path));
+    return '';
+  };
+
   for (let step = 0; step < MAX_STEPS && !finished; step++) {
+    const stop = thinking('Gandeste');
     let data;
     try {
       const res = await fetch(URL, {
@@ -123,16 +160,16 @@ export async function runAgentLoop({ stack, rootDir, files, askRaw, auto, model,
         body: JSON.stringify({ model: usedModel, temperature: 0, tools: TOOLS, messages }),
         signal: AbortSignal.timeout(90_000),
       });
-      if (!res.ok) return { ok: false, reason: 'http_' + res.status };
+      if (!res.ok) { stop(); return { ok: false, reason: 'http_' + res.status }; }
       data = await res.json();
-    } catch (e) { return { ok: false, reason: 'fetch:' + (e?.message || e) }; }
+    } catch (e) { stop(); return { ok: false, reason: 'fetch:' + (e?.message || e) }; }
+    stop();
 
     const msg = data.choices?.[0]?.message;
     if (!msg) return { ok: false, reason: 'no_message' };
     messages.push(msg);
     const calls = msg.tool_calls || [];
     if (calls.length === 0) {
-      // model spoke without a tool call; nudge once, else stop
       if (step > 0 && !finished) break;
       messages.push({ role: 'user', content: 'Continua folosind tool-urile. Cand ai terminat, apeleaza finish.' });
       continue;
@@ -140,6 +177,7 @@ export async function runAgentLoop({ stack, rootDir, files, askRaw, auto, model,
     for (const call of calls) {
       let arg = {};
       try { arg = JSON.parse(call.function.arguments || '{}'); } catch { /* */ }
+      toolLine(NAMES[call.function.name] || call.function.name, brief(call.function.name, arg));
       const fn = tools[call.function.name];
       const result = fn ? await fn(arg) : 'tool necunoscut';
       messages.push({ role: 'tool', tool_call_id: call.id, content: String(result) });

package/src/core/apply.js

@@ -28,30 +28,21 @@ function insideRoot(root, p) {
   return rel && !rel.startsWith('..') && !resolve(p).includes('\0');
 }
 
-// Render a colored preview of the plan. No writes.
+// Compact preview of the plan (one line per change), no writes.
 export function renderPlan(plan, rootDir) {
   for (const nf of plan.newFiles) {
-    out('\n  ' + paint('＋ fisier nou  ', C.green) + paint(relative(rootDir, nf.path), C.white) + '\n');
-    const lines = nf.content.split('\n').slice(0, 14);
-    for (const l of lines) out('    ' + paint('+ ', C.green) + paint(l, C.ink) + '\n');
-    if (nf.content.split('\n').length > 14) out('    ' + paint('  …', C.dim) + '\n');
+    out('  ' + paint('●', C.red) + '  ' + paint('Write ', C.white) +
+      paint(relative(rootDir, nf.path) + '  (' + nf.content.split('\n').length + ' linii)', C.dim) + '\n');
   }
-  // group edits by file
   const byFile = new Map();
   for (const e of plan.edits) {
     if (!byFile.has(e.path)) byFile.set(e.path, []);
     byFile.get(e.path).push(e);
   }
   for (const [file, edits] of byFile) {
-    out('\n  ' + paint('✎ modific     ', C.amber) + paint(relative(rootDir, file), C.white) + '\n');
-    const src = readFileSync(file, 'utf8').split('\n');
-    for (const e of edits.sort((a, b) => a.atLine - b.atLine)) {
-      const ctx = Math.max(0, e.atLine - 2);
-      out('    ' + paint(`@@ linia ${e.atLine}  ${e.reason}`, C.dim) + '\n');
-      for (let i = ctx; i < e.atLine; i++) out('    ' + paint('  ' + (src[i] ?? ''), C.dim) + '\n');
-      for (const ins of e.insert) out('    ' + paint('+ ' + ins, C.green) + '\n');
-      if (src[e.atLine] !== undefined) out('    ' + paint('  ' + src[e.atLine], C.dim) + '\n');
-    }
+    const added = edits.reduce((s, e) => s + e.insert.length, 0);
+    out('  ' + paint('●', C.red) + '  ' + paint('Edit  ', C.white) +
+      paint(relative(rootDir, file) + '  +' + added + ' linii', C.dim) + '\n');
   }
 }
 

package/src/core/detect.js

@@ -9,6 +9,9 @@ const MANIFESTS = [
   { file: 'pyproject.toml', stack: 'python', label: 'Python' },
   { file: 'pom.xml', stack: 'java', label: 'Java' },
   { file: 'build.gradle', stack: 'java', label: 'Java' },
+  { file: 'Gemfile', stack: 'ruby', label: 'Ruby' },
+  { file: 'go.mod', stack: 'go', label: 'Go' },
+  { file: 'Cargo.toml', stack: 'rust', label: 'Rust' },
 ];
 const EXT_STACK = {
   '.cs': { stack: 'csharp', label: 'C# / .NET' },
@@ -21,6 +24,9 @@ const EXT_STACK = {
   '.py': { stack: 'python', label: 'Python' },
   '.ts': { stack: 'node', label: 'Node.js' },
   '.js': { stack: 'node', label: 'Node.js' },
+  '.rb': { stack: 'ruby', label: 'Ruby' },
+  '.go': { stack: 'go', label: 'Go' },
+  '.rs': { stack: 'rust', label: 'Rust' },
 };
 const IGNORE = new Set(['node_modules', '.git', 'dist', 'build', 'bin', 'obj', 'vendor', '.next', '__pycache__']);
 

package/src/ui/anim.js

@@ -29,35 +29,55 @@ function topBar() {
   out(C.onRed + ansi.bold + left + ' '.repeat(gap) + right + ansi.reset + '\n');
 }
 
-// Polished startup screen: a top bar, the real logo (rendered from the actual
-// brand image into ANSI), a title, and a short description of what the tool
-// does, then an animated status line. Inspired by the PostHog wizard layout.
+// Thinking indicator (Claude-style morphing star + elapsed time). Returns a
+// stop() that clears the line so the next output starts clean.
+const STARS = ['✶', '✸', '✹', '✺', '✦', '✧'];
+export function thinking(label = 'Gandeste') {
+  if (!ANIM) { out('  ' + paint('✶', C.red) + ' ' + paint(label, C.ink) + '…\n'); return () => {}; }
+  out(ansi.hideCursor);
+  let i = 0;
+  const t0 = Date.now();
+  const id = setInterval(() => {
+    const s = Math.round((Date.now() - t0) / 1000);
+    out(ansi.toLineStart + ansi.clearLine + '  ' + paint(STARS[i++ % STARS.length], C.red) +
+      '  ' + paint(label, C.ink) + paint('…  ' + s + 's', C.dim));
+  }, 95);
+  return () => { clearInterval(id); out(ansi.toLineStart + ansi.clearLine + ansi.showCursor); };
+}
+
+// Compact tool-call line, Claude-style: ●  Tool  brief
+export function toolLine(name, brief = '') {
+  out('  ' + paint('●', C.red) + '  ' + paint(name.padEnd(6), C.white) +
+    (brief ? paint(brief, C.dim) : '') + '\n');
+}
+
+async function swayLogo(logo, frames = [0, 1, 2, 1, 0, -1, -2, -1, 0]) {
+  if (!ANIM) return;
+  const base = Math.max(0, Math.floor((cols() - 26) / 2));
+  for (const off of frames) {
+    out(ansi.up(logo.length));
+    for (const line of logo) out(ansi.clearLine + ' '.repeat(Math.max(0, base + off)) + line + '\n');
+    await sleep(70);
+  }
+}
+
+// Startup screen: top bar, the real (image-rendered) logo that reveals then
+// gently sways, a title, and one line. Terse.
 export async function logoIntro() {
   if (!ANIM) {
     out(paint('  Fidelizare', C.red) + paint('  ·  asistent de integrare\n\n', C.ink));
     return;
   }
-  out('\x1b[2J\x1b[H' + ansi.hideCursor); // clear screen, home
+  out('\x1b[2J\x1b[H' + ansi.hideCursor);
   topBar();
   out('\n');
-
   const logo = loadLogo();
-  for (const line of logo) {
-    out(center(line, 26) + '\n');
-    await sleep(26);
-  }
+  for (const line of logo) { out(center(line, 26) + '\n'); await sleep(24); }
+  await swayLogo(logo);
   out('\n');
-
   const title = ansi.bold + C.red + 'FIDELIZARE' + ansi.reset + paint('  ·  asistent de integrare', C.ink);
   out(center(title, 'FIDELIZARE  ·  asistent de integrare'.length) + '\n\n');
-  await sleep(120);
-
-  const d1 = 'Iti analizam codul si integram API-ul de fidelizare, in cativa pasi.';
-  const d2 = 'Cheile si .env raman pe calculatorul tau, nu pleaca nicaieri.';
-  out(center(paint(d1, C.white), d1.length) + '\n');
-  await sleep(80);
-  out(center(paint(d2, C.dim), d2.length) + '\n\n');
-  await sleep(120);
+  await sleep(140);
   out(ansi.showCursor);
 }