git-push-time 1.0.0 → 1.0.1

package/lib/fix.js

@@ -0,0 +1,260 @@
+import { spawnSync, execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { findRiskyStagedFiles } from './git.js';
+import { scanStagedContentForSecrets } from './secrets.js';
+
+/**
+ * Danh sách phần mở rộng của file mã nguồn / tài liệu.
+ * KHÔNG BAO GIỜ tự động thêm các file này vào .gitignore vì sẽ làm mất code dự án!
+ */
+const CODE_EXTENSIONS = new Set([
+  '.js', '.mjs', '.cjs', '.jsx', '.ts', '.tsx',
+  '.py', '.java', '.go', '.rs', '.c', '.cpp', '.cc', '.h', '.hpp',
+  '.cs', '.php', '.rb', '.html', '.htm', '.css', '.scss', '.sass',
+  '.less', '.vue', '.svelte', '.md', '.markdown', '.txt', '.sh',
+  '.bash', '.zsh', '.bat', '.cmd', '.ps1', '.sql'
+]);
+
+function isCodeOrDocFile(filePath) {
+  const base = path.basename(filePath).toLowerCase();
+  const ext = path.extname(filePath).toLowerCase();
+  if (base === 'package.json' || base === 'package-lock.json' || base === 'tsconfig.json') return true;
+  return CODE_EXTENSIONS.has(ext);
+}
+
+/**
+ * Tự fix an toàn khi phát hiện secret:
+ *  1. git rm --cached -r -f <file> (gỡ khỏi commit, giữ nguyên file trên máy)
+ *  2. Thêm rule tương ứng vào .gitignore (chỉ áp dụng cho file cấu hình secret, KHÔNG ignore file code)
+ *  3. Tự động stage lại .gitignore để sẵn sàng commit
+ *
+ * @param {string[]} files danh sách file cần gỡ (vd ['.env', '.npmrc'])
+ * @param {string} cwd
+ * @returns {{ fixed: string[], alreadyClean: string[], failed: {file:string, reason:string}[], gitignoreAdded: string[], codeFilesWithSecrets: string[] }}
+ */
+export function autoFixStagedSecrets(files = [], cwd = process.cwd()) {
+  const unique = [...new Set((files || []).map((f) => String(f).trim()).filter(Boolean))];
+  const result = {
+    fixed: [],
+    alreadyClean: [],
+    failed: [],
+    gitignoreAdded: [],
+    codeFilesWithSecrets: []
+  };
+  if (unique.length === 0) return result;
+
+  for (const file of unique) {
+    const normalized = file.replace(/\\/g, '/');
+    let ok = false;
+    let errReason = '';
+
+    // 1. Thử gỡ khỏi stage bằng git rm --cached -r -f
+    const r = spawnSync('git', ['rm', '--cached', '-r', '-f', '--', normalized], { cwd, encoding: 'utf-8' });
+    if (r.status === 0) {
+      ok = true;
+    } else {
+      const msg = String(r.stderr || r.stdout || '');
+      // Thử fallback bằng git restore --staged nếu git rm báo pathspec/not matched
+      const rRestore = spawnSync('git', ['restore', '--staged', '--', normalized], { cwd, encoding: 'utf-8' });
+      if (rRestore.status === 0) {
+        ok = true;
+      } else if (/did not match|pathspec/i.test(msg)) {
+        result.alreadyClean.push(file);
+        continue;
+      } else {
+        errReason = msg.trim().split('\n')[0] || 'unknown error';
+      }
+    }
+
+    if (ok) {
+      result.fixed.push(file);
+    } else if (errReason) {
+      result.failed.push({ file, reason: errReason });
+    }
+  }
+
+  // 2. Phân loại và tạo rule .gitignore cho các file config secret (bỏ qua file code)
+  const rules = [];
+  for (const f of unique) {
+    const normalized = f.replace(/\\/g, '/');
+    const base = path.basename(normalized);
+
+    if (isCodeOrDocFile(normalized)) {
+      // File mã nguồn có dính secret: gỡ khỏi stage nhưng không cho vào .gitignore
+      result.codeFilesWithSecrets.push(f);
+      continue;
+    }
+
+    if (/^\.env(\..+)?$/i.test(base)) {
+      rules.push('.env*');
+    } else if (base.toLowerCase() === '.npmrc') {
+      rules.push('.npmrc');
+    } else if (/\.pem$|\.key$/i.test(base)) {
+      rules.push('*.pem\n*.key');
+    } else if (/id_rsa|id_ed25519|id_ecdsa|id_dsa/i.test(base)) {
+      rules.push('id_rsa*\nid_ed25519*\nid_ecdsa*');
+    } else if (/secrets?\.json$|credentials?\.json$|service-account.*\.json$/i.test(base)) {
+      rules.push('*secret*.json\n*credential*.json');
+    } else if (/\.pfx$|\.p12$/i.test(base)) {
+      rules.push('*.pfx\n*.p12');
+    } else {
+      rules.push(normalized);
+    }
+  }
+
+  const gitignorePath = path.join(cwd, '.gitignore');
+  let existing = '';
+  try {
+    if (fs.existsSync(gitignorePath)) existing = fs.readFileSync(gitignorePath, 'utf-8');
+  } catch { existing = ''; }
+
+  const existingLines = new Set(existing.split(/\r?\n/).map((l) => l.trim()));
+  const toAdd = [];
+  for (const chunk of rules) {
+    for (const line of String(chunk).split(/\r?\n/)) {
+      const t = line.trim();
+      if (t && !existingLines.has(t)) {
+        toAdd.push(t);
+        existingLines.add(t);
+      }
+    }
+  }
+
+  if (toAdd.length > 0) {
+    try {
+      const prefix = existing.length > 0 && !existing.endsWith('\n') ? '\n' : '';
+      fs.appendFileSync(gitignorePath, prefix + toAdd.join('\n') + '\n', 'utf-8');
+      result.gitignoreAdded = toAdd;
+
+      // Tự động stage ngay .gitignore để không bị sót khi commit
+      spawnSync('git', ['add', '.gitignore'], { cwd });
+    } catch {
+      // Bỏ qua lỗi ghi file
+    }
+  }
+
+  return result;
+}
+
+/** Kiểm tra còn gì để commit sau khi auto-fix không */
+export function hasStagedChanges(cwd = process.cwd()) {
+  try {
+    const out = execSync('git diff --cached --name-only', { cwd, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
+    return out.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Quét các file secret phổ biến trong thư mục làm việc nhưng chưa được ignore trong .gitignore
+ */
+export function findRiskyWorkingTreeFiles(cwd = process.cwd()) {
+  const denyNames = [
+    '.env', '.env.local', '.env.development', '.env.production',
+    '.npmrc', 'secrets.json', 'secret.json', 'credentials.json',
+    'id_rsa', 'id_ed25519'
+  ];
+  const found = [];
+  for (const name of denyNames) {
+    const fullPath = path.join(cwd, name);
+    if (fs.existsSync(fullPath)) {
+      const r = spawnSync('git', ['check-ignore', '-q', name], { cwd });
+      if (r.status !== 0) {
+        found.push(name);
+      }
+    }
+  }
+  return found;
+}
+
+/**
+ * Tìm upstream ref của branch hiện tại (VD: origin/main hoặc origin/master)
+ */
+export function getUpstreamRef(branch = 'main', cwd = process.cwd()) {
+  try {
+    const upstream = execSync(`git rev-parse --abbrev-ref ${branch}@{u}`, { cwd, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    if (upstream) return upstream;
+  } catch {}
+
+  const candidates = [`origin/${branch}`, 'origin/main', 'origin/master'];
+  for (const ref of candidates) {
+    try {
+      execSync(`git rev-parse --verify ${ref}`, { cwd, stdio: 'ignore' });
+      return ref;
+    } catch {}
+  }
+  return null;
+}
+
+/**
+ * Lấy danh sách các commit unpushed (chưa đẩy lên remote)
+ */
+export function getUnpushedCommits(branch = 'main', cwd = process.cwd()) {
+  const upstream = getUpstreamRef(branch, cwd);
+  if (!upstream) {
+    try {
+      const log = execSync('git log --oneline', { cwd, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
+      return log.trim().split(/\r?\n/).filter(Boolean);
+    } catch {
+      return [];
+    }
+  }
+  try {
+    const log = execSync(`git log ${upstream}..HEAD --oneline`, { cwd, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
+    return log.trim().split(/\r?\n/).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Squash các commit chưa push thành 1 commit duy nhất sạch sẽ,
+ * loại bỏ hoàn toàn dấu vết secret ở các commit trung gian (ví dụ commit cũ chứa .npmrc hay .env).
+ */
+export function squashUnpushedCommits(branch = 'main', commitMsg = 'Clean commit without secrets', dateFormatted = null, cwd = process.cwd()) {
+  const upstream = getUpstreamRef(branch, cwd);
+  try {
+    if (upstream) {
+      const r1 = spawnSync('git', ['reset', '--soft', upstream], { cwd, encoding: 'utf-8' });
+      if (r1.status !== 0) {
+        throw new Error(r1.stderr || 'Không thể reset về upstream');
+      }
+    } else {
+      // Chưa có upstream (repo mới hoàn toàn)
+      const rootCommit = execSync('git rev-list --max-parents=0 HEAD', { cwd, encoding: 'utf-8' }).trim().split(/\s+/)[0];
+      if (rootCommit) {
+        spawnSync('git', ['reset', '--soft', rootCommit], { cwd });
+      }
+    }
+
+    // Quét lại và loại bỏ bất kỳ secret file nào còn sót trong staged
+    const risky = findRiskyStagedFiles(cwd);
+    const findings = scanStagedContentForSecrets(cwd);
+    const allSecretFiles = [...new Set([...risky, ...findings.map((f) => f.file)])];
+    if (allSecretFiles.length > 0) {
+      autoFixStagedSecrets(allSecretFiles, cwd);
+    }
+
+    // Đảm bảo .gitignore được stage
+    spawnSync('git', ['add', '.gitignore'], { cwd });
+
+    // Tạo commit mới sạch
+    const env = { ...process.env };
+    if (dateFormatted) {
+      env.GIT_AUTHOR_DATE = dateFormatted;
+      env.GIT_COMMITTER_DATE = dateFormatted;
+    }
+    const rCommit = spawnSync('git', ['commit', '-m', commitMsg], { cwd, env, encoding: 'utf-8' });
+    if (rCommit.status !== 0) {
+      const msg = rCommit.stderr || rCommit.stdout || '';
+      if (!msg.includes('nothing to commit')) {
+        throw new Error(msg || 'Lỗi khi tạo commit squash');
+      }
+    }
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}

package/lib/git.js

@@ -132,7 +132,7 @@ export function commitWithCustomDate(message, dateFormatted, cwd = process.cwd()
  * Đẩy code lên Git remote repo
  * @param {string} branch Tên branch (VD: main)
  * @param {boolean} force Có sử dụng --force hay không
- * @param {string} cwd 
+ * @param {string} cwd
  */
 export function pushToRemote(branch = 'main', force = false, cwd = process.cwd()) {
   const args = ['push', '-u', 'origin', branch];
@@ -147,7 +147,97 @@ export function pushToRemote(branch = 'main', force = false, cwd = process.cwd()
   });
 
   if (result.status !== 0) {
-    const stderr = result.stderr || result.stdout || 'Lỗi không xác định khi git push';
-    throw new Error(stderr.trim());
+    const raw = (result.stderr || result.stdout || 'Lỗi không xác định khi git push').trim();
+    const parsed = parsePushError(raw);
+    const err = new Error(raw);
+    err.code = parsed.code;
+    err.details = parsed;
+    throw err;
+  }
+}
+
+/**
+ * Phân loại lỗi khi `git push` thất bại để CLI hiển thị hướng dẫn thân thiện.
+ * Đặc biệt xử lý GitHub Push Protection (GH013) khi push dính secret.
+ *
+ * @param {string} rawOutput stderr/stdout từ git push
+ * @returns {{ code: string, secretTypes: string[], files: string[], unblockUrl: string | null, resolveUrl: string | null }}
+ */
+export function parsePushError(rawOutput = '') {
+  const text = String(rawOutput || '');
+  const lower = text.toLowerCase();
+
+  const isSecretBlocked =
+    /gh0?13/.test(text) ||
+    lower.includes('push protection') ||
+    lower.includes('push cannot contain secrets') ||
+    lower.includes('secret scanning') ||
+    lower.includes('repository rule violations') ||
+    (lower.includes('blocked') && lower.includes('secret')) ||
+    (lower.includes('detected') && lower.includes('secret'));
+
+  if (isSecretBlocked) {
+    // VD: "—— npm Access Token ——" hoặc "— Generic API Key —"
+    const secretTypes = [];
+    const typeRegex = /[—\-]{2,}\s*([A-Za-z0-9 _.'()/+-]+?(?:token|key|secret|password|private key)[A-Za-z0-9 _.'()/+-]*?)\s*[—\-]{2,}/gi;
+    let m;
+    while ((m = typeRegex.exec(text)) !== null) {
+      const name = m[1].trim();
+      if (name && !secretTypes.includes(name)) secretTypes.push(name);
+    }
+
+    // VD: "- commit abc123: .npmrc:1" hoặc "file: .env"
+    const files = [];
+    const fileRegex = /(?:commit\s+[0-9a-f]{4,40}\s*:\s*)([^\s:]+\.[A-Za-z0-9_.-]+)/gi;
+    while ((m = fileRegex.exec(text)) !== null) {
+      if (!files.includes(m[1])) files.push(m[1]);
+    }
+    // fallback: tìm tên file khả nghi trong output
+    const fallbackRegex = /(^|\s)(`?\.?(env|npmrc|id_rsa|id_ed25519|.*\.pem|.*\.key))\b/gi;
+    while ((m = fallbackRegex.exec(text)) !== null) {
+      const f = m[2].replace(/`/g, '');
+      if (!files.includes(f)) files.push(f);
+    }
+
+    const unblockMatch = text.match(/https:\/\/github\.com\/[^\s) '"]*unblock-secret[^\s) '"]*/i);
+    const resolveMatch = text.match(/https:\/\/docs\.github\.com\/[^\s) '"]*push-protection[^\s) '"]*/i);
+
+    return {
+      code: 'SECRET_BLOCKED',
+      secretTypes,
+      files,
+      unblockUrl: unblockMatch ? unblockMatch[0] : null,
+      resolveUrl: resolveMatch ? resolveMatch[0] : 'https://docs.github.com/code-security/secret-scanning/pushing-a-branch-blocked-by-push-protection'
+    };
+  }
+
+  if (lower.includes('authentication failed') || lower.includes('could not read username') || lower.includes('invalid username or password') || lower.includes('permission denied')) {
+    return { code: 'AUTH_FAILED', secretTypes: [], files: [], unblockUrl: null, resolveUrl: null };
+  }
+  if (lower.includes('non-fast-forward') || lower.includes('failed to push some refs') || lower.includes('fetch first') || lower.includes('rejected')) {
+    return { code: 'NON_FAST_FORWARD', secretTypes: [], files: [], unblockUrl: null, resolveUrl: null };
+  }
+  if (lower.includes('repository not found') || lower.includes('could not resolve host') || lower.includes('network') || lower.includes('unable to access')) {
+    return { code: 'REMOTE_OR_NETWORK', secretTypes: [], files: [], unblockUrl: null, resolveUrl: null };
+  }
+  return { code: 'UNKNOWN', secretTypes: [], files: [], unblockUrl: null, resolveUrl: null };
+}
+
+/**
+ * Quét nhanh staged files để cảnh báo TRƯỚC khi commit/push.
+ * Chỉ cảnh báo, không chặn — tránh false-positive.
+ * @param {string} cwd
+ * @returns {string[]} danh sách file khả nghi
+ */
+export function findRiskyStagedFiles(cwd = process.cwd()) {
+  const denyList = [/^\.env(\..+)?$/, /^\.npmrc$/, /_rsa$/, /_ed25519$/, /\.pem$/, /\.key$/, /secrets?\.json$/i];
+  try {
+    const out = execSync('git diff --cached --name-only', { cwd, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
+    return out.split('\n').map((s) => s.trim()).filter(Boolean).filter((f) => {
+      const base = path.basename(f);
+      return denyList.some((re) => re.test(base) || re.test(f));
+    });
+  } catch {
+    return [];
   }
 }

package/lib/npm.js

@@ -0,0 +1,82 @@
+import { spawnSync, execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+
+export function checkNpmInstalled() {
+  try {
+    execSync('npm --version', { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function getPackageInfo(cwd = process.cwd()) {
+  try {
+    const raw = fs.readFileSync(path.join(cwd, 'package.json'), 'utf-8');
+    const pkg = JSON.parse(raw);
+    return { name: pkg.name || '(chưa đặt tên)', version: pkg.version || '0.0.0', hasPublishConfig: !!pkg.publishConfig };
+  } catch {
+    return null;
+  }
+}
+
+/** Đang login npm chưa? (không in token ra) */
+export function checkNpmLogin(cwd = process.cwd()) {
+  const r = spawnSync('npm', ['whoami'], { cwd, encoding: 'utf-8' });
+  if (r.status === 0) return { loggedIn: true, user: r.stdout.trim() };
+  return { loggedIn: false, user: null };
+}
+
+/**
+ * Cảnh báo nếu .npmrc chứa token đang bị track trong git.
+ * Chỉ kiểm tra tên file, KHÔNG đọc/in token.
+ */
+export function isNpmrcTracked(cwd = process.cwd()) {
+  try {
+    const out = execSync('git ls-files', { cwd, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
+    return out.split('\n').map((s) => s.trim()).includes('.npmrc');
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Publish lên npm. Token lấy từ `npm login` hoặc env NPM_TOKEN,
+ * KHÔNG nhận token qua flag để tránh lộ trong shell history.
+ */
+export function publishToNpm({ access = 'public', dryRun = false, cwd = process.cwd() } = {}) {
+  const args = ['publish'];
+  if (access) args.push('--access', access);
+  if (dryRun) args.push('--dry-run');
+
+  const env = { ...process.env };
+  // Ưu tiên NPM_TOKEN từ env nếu có (CI). Không log giá trị này.
+  if (env.NPM_TOKEN && !env.NODE_AUTH_TOKEN) {
+    env.NODE_AUTH_TOKEN = env.NPM_TOKEN;
+  }
+
+  const r = spawnSync('npm', args, { cwd, encoding: 'utf-8', env });
+  const output = ((r.stdout || '') + '\n' + (r.stderr || '')).trim();
+  if (r.status === 0) {
+    return { ok: true, output };
+  }
+  return { ok: false, output, parsed: parseNpmError(output) };
+}
+
+export function parseNpmError(output = '') {
+  const lower = output.toLowerCase();
+  if (lower.includes('eneedauth') || lower.includes('need auth') || lower.includes('401') || lower.includes('you must be logged in')) {
+    return { code: 'NEED_AUTH', hint: 'Chưa login npm. Chạy: npm login  (hoặc set env NPM_TOKEN khi chạy CI)' };
+  }
+  if (lower.includes('e403') || lower.includes('403 forbidden')) {
+    return { code: 'FORBIDDEN', hint: 'Không có quyền publish tên này (bị trùng tên hoặc chưa được add collaborator). Đổi name trong package.json hoặc xin quyền.' };
+  }
+  if (lower.includes('epublishconflict') || lower.includes('cannot publish over previously published')) {
+    return { code: 'VERSION_EXISTS', hint: 'Version này đã tồn tại. Tăng version: npm version patch  rồi publish lại.' };
+  }
+  if (lower.includes('e400') || lower.includes('invalid package name') || lower.includes('invalid name')) {
+    return { code: 'BAD_NAME', hint: 'Tên package chưa hợp lệ trong package.json (chữ thường, không dấu cách).' };
+  }
+  return { code: 'UNKNOWN', hint: 'Xem log npm phía trên để biết chi tiết.' };
+}

package/lib/secrets.js

@@ -0,0 +1,87 @@
+import { execSync } from 'child_process';
+
+// Pattern quét secret phổ biến. Giữ ở mức precision cao để tránh false-positive.
+export const SECRET_PATTERNS = [
+  { id: 'npm-token', label: 'npm Access Token', regex: /npm_[A-Za-z0-9]{8,}/ },
+  { id: 'npm-authtoken', label: '_authToken trong .npmrc', regex: /_authToken\s*=\s*\S+/i },
+  { id: 'github-token', label: 'GitHub Token (ghp_/gho_/github_pat_)', regex: /\b(ghp_[A-Za-z0-9]{20,}|gho_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{40,})\b/ },
+  { id: 'aws-key', label: 'AWS Access Key (AKIA...)', regex: /\bAKIA[0-9A-Z]{16}\b/ },
+  { id: 'aws-secret', label: 'AWS Secret Key', regex: /aws_secret_access_key\s*=\s*\S+/i },
+  { id: 'private-key', label: 'Private Key (PEM)', regex: /-----BEGIN (RSA |EC |OPENSSH |DSA )?PRIVATE KEY-----/ },
+  { id: 'openai-key', label: 'OpenAI API Key', regex: /\bsk-(proj-)?[A-Za-z0-9_-]{20,}\b/ },
+  { id: 'slack-token', label: 'Slack Token', regex: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/ },
+  { id: 'google-key', label: 'Google API Key', regex: /\bAIza[0-9A-Za-z_-]{30,}\b/ },
+  { id: 'generic-password', label: 'Password gán cứng', regex: /\b(password|passwd|pwd)\s*[:=]\s*['"][^'"]{4,}['"]/i },
+];
+
+const SKIP_DIRS = ['node_modules/', '.git/', 'dist/', 'build/', '.next/'];
+const SKIP_FILES = ['package-lock.json', 'yarn.lock', 'pnpm-lock.yaml'];
+const MAX_FILE_BYTES = 512 * 1024; // bỏ qua file staged > 512KB
+const MAX_MATCHES_PER_FILE = 3;
+
+function listStagedFiles(cwd) {
+  try {
+    const out = execSync('git diff --cached --name-only --diff-filter=ACM', {
+      cwd, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore']
+    });
+    return out.split('\n').map((s) => s.trim()).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function readStagedContent(file, cwd) {
+  try {
+    // Đọc nội dung đã stage (git show :path), không phải file ngoài disk
+    const content = execSync(`git show :"${file.replace(/"/g, '')}"`, {
+      cwd, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'], maxBuffer: MAX_FILE_BYTES * 2
+    });
+    if (content.length > MAX_FILE_BYTES) return null; // file quá lớn, bỏ qua
+    if (content.includes('\0')) return null; // file binary
+    return content;
+  } catch {
+    return null;
+  }
+}
+
+function redactPreview(line) {
+  const s = line.trim().slice(0, 120);
+  // Che giữa secret, chỉ chừa 4 ký tự đầu/cuối
+  return s.replace(/([A-Za-z0-9_.-]{4})[A-Za-z0-9_.-]{6,}([A-Za-z0-9_.-]{2})?/g, '$1•••$2');
+}
+
+/**
+ * Quét nội dung các file đã stage để tìm secret.
+ * @param {string} cwd
+ * @returns {{ file: string, type: string, line: number, preview: string }[]}
+ */
+export function scanStagedContentForSecrets(cwd = process.cwd()) {
+  const findings = [];
+  const files = listStagedFiles(cwd).filter((f) => {
+    if (SKIP_DIRS.some((d) => f.startsWith(d))) return false;
+    if (SKIP_FILES.includes(f.split('/').pop())) return false;
+    return true;
+  });
+
+  for (const file of files.slice(0, 100)) { // giới hạn 100 file để nhanh
+    const content = readStagedContent(file, cwd);
+    if (!content) continue;
+    const lines = content.split('\n');
+    let matchesInFile = 0;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (!line || line.length > 2000) continue;
+      // Bỏ qua comment ví dụ trong docs? vẫn báo để user tự quyết
+      for (const p of SECRET_PATTERNS) {
+        if (p.regex.test(line)) {
+          findings.push({ file, type: p.label, line: i + 1, preview: redactPreview(line) });
+          matchesInFile++;
+          break; // mỗi dòng chỉ báo 1 lần
+        }
+      }
+      if (matchesInFile >= MAX_MATCHES_PER_FILE) break;
+      if (findings.length >= 20) return findings; // chặn spam
+    }
+  }
+  return findings;
+}