fidelizare-integrate 0.3.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fidelizare-integrate",
-  "version": "0.3.0",
+  "version": "0.5.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');
@@ -87,14 +87,21 @@ async function main() {
 
   const git = gitState(root);
 
-  // 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)) {
+  // 5a. Agentic tool-loop (real coding agent) — the DEFAULT when an LLM key is
+  // available. The model finds the files and applies the integration itself,
+  // each write gated. `--no-agent` forces the basic deterministic proposer.
+  const llmKey = process.env.OPENROUTER_API_KEY || process.env.FIDELIZARE_LLM_KEY;
+  if (!has('--no-agent') && !llmKey) {
+    note('Pentru integrare cu AI (recomandat), seteaza OPENROUTER_API_KEY. Acum folosesc modul determinist de baza.', C.amber);
+    rule();
+  }
+  if (!has('--no-agent') && llmKey) {
     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'),
+      guideUrl: val('--guide') || process.env.FIDELIZARE_GUIDE_URL,
     });
     if (r.ok) {
       writeEnv(root, vaultResolve(keyRef));

package/src/core/agent-loop.js

@@ -8,7 +8,7 @@
 // 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';
@@ -16,21 +16,30 @@ 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: {} } } },
@@ -38,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));
@@ -54,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();
@@ -94,6 +106,25 @@ export async function runAgentLoop({ stack, rootDir, files, askRaw, auto, model,
       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';
@@ -106,12 +137,14 @@ 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', check_syntax: 'Check', finish: 'Done' };
+  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 '';

package/src/core/detect.js

@@ -1,6 +1,6 @@
 // Detect the vendor's stack from manifest/extension signals. Read-only.
-import { readdirSync, existsSync, statSync } from 'fs';
-import { join, extname } from 'path';
+import { readdirSync, existsSync, statSync, readFileSync } from 'fs';
+import { join, extname, basename } from 'path';
 
 const MANIFESTS = [
   { file: 'composer.json', stack: 'php', label: 'PHP' },
@@ -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,11 +24,51 @@ 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__']);
+// Build artifacts, dependencies and tooling dirs — never integration targets.
+// Mirrors what ripgrep skips via .gitignore (opencode uses ripgrep).
+const IGNORE = new Set([
+  'node_modules', '.git', '.next', '.nuxt', '.svelte-kit', '.parcel-cache', '.turbo', '.cache',
+  'dist', 'build', 'out', 'bin', 'obj', 'target', 'vendor', 'coverage', '__pycache__',
+  '.venv', 'venv', 'env', '.idea', '.vscode', '.gradle', 'static', 'tmp', '.expo',
+]);
+// Minified / generated bundles by filename.
+const MINIFIED_NAME = /(\.min\.|\.bundle\.|\.chunk\.|[-_.]esm[-_.]|node_modules_|\.d\.ts$|\.map$)/i;
+
+function loadGitignoreNames(dir) {
+  // Cheap .gitignore support: collect simple directory/file names to skip.
+  const names = new Set();
+  try {
+    for (const line of readFileSync(join(dir, '.gitignore'), 'utf8').split('\n')) {
+      const t = line.trim();
+      if (!t || t.startsWith('#') || t.startsWith('!')) continue;
+      const name = t.replace(/^\/+/, '').replace(/\/+$/, '');
+      if (name && !name.includes('/') && !name.includes('*')) names.add(name);
+    }
+  } catch { /* no .gitignore */ }
+  return names;
+}
+
+// A real source file looks hand-written: not minified, not huge, sane line length.
+function looksLikeSource(file) {
+  if (MINIFIED_NAME.test(basename(file))) return false;
+  try {
+    if (statSync(file).size > 200_000) return false;
+    const head = readFileSync(file, 'utf8').slice(0, 4000);
+    if (!head.includes('\n') && head.length > 1200) return false; // single huge line
+    const lines = head.split('\n').slice(0, 40);
+    const avg = lines.reduce((s, l) => s + l.length, 0) / Math.max(1, lines.length);
+    if (avg > 400) return false; // minified
+  } catch { return false; }
+  return true;
+}
 
 export function listSourceFiles(dir, max = 4000) {
   const out = [];
+  const ignored = new Set([...IGNORE, ...loadGitignoreNames(dir)]);
   const walk = (d) => {
     if (out.length >= max) return;
     let entries;
@@ -33,10 +76,10 @@ export function listSourceFiles(dir, max = 4000) {
     for (const e of entries) {
       if (out.length >= max) return;
       if (e.name.startsWith('.') && e.name !== '.') continue;
-      if (IGNORE.has(e.name)) continue;
+      if (ignored.has(e.name)) continue;
       const p = join(d, e.name);
       if (e.isDirectory()) walk(p);
-      else if (EXT_STACK[extname(e.name).toLowerCase()]) out.push(p);
+      else if (EXT_STACK[extname(e.name).toLowerCase()] && looksLikeSource(p)) out.push(p);
     }
   };
   walk(dir);