@kb-labs/commit-core 0.6.0

package/README.md

@@ -0,0 +1,23 @@
+# @kb-labs/commit-core
+
+Core business logic for KB Labs Commit plugin - git analysis, plan generation, and commit application.
+
+## Installation
+
+```bash
+pnpm add @kb-labs/commit-core
+```
+
+## Usage
+
+```typescript
+import { ... } from '@kb-labs/commit-core';
+```
+
+## API
+
+See TypeScript types for detailed API documentation.
+
+## License
+
+MIT

package/dist/analyzer/index.d.ts

@@ -0,0 +1,90 @@
+export { F as FileDiff, j as detectCommitStyle, f as formatFileSummary, a as getAllChangedFiles, b as getCurrentBranch, d as getFileDiff, k as getFileDiffs, c as getFileSummaries, g as getGitStatus, e as getRecentCommits, h as hasChanges, i as isProtectedBranch } from '../recent-commits-DD6LX2OI.js';
+import '@kb-labs/commit-contracts';
+
+/**
+ * Scope resolver - converts package names to file path patterns
+ * Supports:
+ * 1. Exact package name: @kb-labs/core, my-package
+ * 2. Wildcard pattern: @kb-labs/core-*, packages/*
+ * 3. Path pattern: packages/core/src/**
+ */
+interface ResolvedScope {
+    /** Original scope string */
+    original: string;
+    /** Type of scope */
+    type: "package-name" | "wildcard" | "path-pattern";
+    /** Resolved package paths (directories) */
+    packagePaths: string[];
+    /** Pattern to filter files (glob or regex) */
+    filePattern?: string;
+}
+interface PackageInfo {
+    name: string;
+    path: string;
+}
+/**
+ * Resolve scope to package paths and file pattern
+ */
+declare function resolveScope(cwd: string, scope: string): Promise<ResolvedScope>;
+/**
+ * Check if a file matches the resolved scope
+ */
+declare function matchesScope(filePath: string, resolvedScope: ResolvedScope): boolean;
+
+/**
+ * Secrets detection module
+ * Detects files that likely contain secrets and should not be sent to LLM
+ */
+/**
+ * Custom error class for secrets detection
+ * This error should NEVER be caught and fallback to heuristics
+ */
+declare class SecretsDetectedError extends Error {
+    readonly secretMatches: SecretMatch[];
+    constructor(matches: SecretMatch[], message: string);
+}
+/**
+ * Detailed information about a detected secret
+ */
+interface SecretMatch {
+    file: string;
+    line: number;
+    column: number;
+    pattern: string;
+    patternName: string;
+    snippet: string;
+    matchedText: string;
+}
+/**
+ * Check if file path matches secret file patterns
+ */
+declare function isSecretFile(filePath: string): boolean;
+/**
+ * Check if file content contains secret patterns
+ */
+declare function containsSecrets(content: string): boolean;
+/**
+ * Scan files for potential secrets
+ * Returns list of files that likely contain secrets
+ */
+declare function detectSecretFiles(files: string[]): string[];
+/**
+ * Scan file diffs for secrets
+ * Returns map of files that contain secrets
+ */
+declare function detectSecretsInDiffs(diffs: Map<string, string>): Map<string, string>;
+/**
+ * Create error message for detected secrets
+ */
+declare function formatSecretsWarning(secretFiles: string[]): string;
+/**
+ * Detect secrets in file diffs with exact location information
+ * Returns array of SecretMatch with file, line, column, pattern info
+ */
+declare function detectSecretsWithLocation(diffs: Map<string, string>): SecretMatch[];
+/**
+ * Format detailed secrets report with locations
+ */
+declare function formatSecretsReport(matches: SecretMatch[]): string;
+
+export { type PackageInfo, type ResolvedScope, type SecretMatch, SecretsDetectedError, containsSecrets, detectSecretFiles, detectSecretsInDiffs, detectSecretsWithLocation, formatSecretsReport, formatSecretsWarning, isSecretFile, matchesScope, resolveScope };

package/dist/analyzer/index.js

@@ -0,0 +1,588 @@
+import { simpleGit } from 'simple-git';
+import { readFile } from 'fs/promises';
+import { join, relative } from 'path';
+import globby from 'globby';
+import { minimatch } from 'minimatch';
+
+// src/analyzer/git-status.ts
+async function getGitStatus(cwd) {
+  const git = simpleGit(cwd);
+  const status = await git.status(["--ignore-submodules=all"]);
+  return {
+    staged: status.staged.filter((f) => !shouldIgnoreFile(f)),
+    unstaged: [...status.modified, ...status.deleted].filter((f) => !status.staged.includes(f)).filter((f) => !shouldIgnoreFile(f)),
+    untracked: status.not_added.filter((f) => !shouldIgnoreFile(f))
+  };
+}
+function shouldIgnoreFile(file) {
+  const ignoredPaths = [
+    "node_modules/",
+    ".git/",
+    "dist/",
+    "build/",
+    ".next/",
+    ".turbo/",
+    "coverage/",
+    ".cache/",
+    ".temp/",
+    "tmp/"
+  ];
+  return ignoredPaths.some((path) => file.includes(path));
+}
+function getAllChangedFiles(status) {
+  const allFiles = [
+    .../* @__PURE__ */ new Set([...status.staged, ...status.unstaged, ...status.untracked])
+  ];
+  return allFiles.filter((file) => !shouldIgnoreFile(file));
+}
+function hasChanges(status) {
+  return status.staged.length > 0 || status.unstaged.length > 0 || status.untracked.length > 0;
+}
+async function getCurrentBranch(cwd) {
+  const git = simpleGit(cwd);
+  const branch = await git.revparse(["--abbrev-ref", "HEAD"]);
+  return branch.trim();
+}
+function isProtectedBranch(branch) {
+  const protectedBranches = [
+    "main",
+    "master",
+    "develop",
+    "release",
+    "production"
+  ];
+  return protectedBranches.includes(branch.toLowerCase());
+}
+function isTextFile(file) {
+  return !file.binary;
+}
+async function isNewFile(cwd, filePath) {
+  try {
+    const repo = await findGitRepo(cwd, filePath);
+    if (!repo) {
+      return true;
+    }
+    const git = simpleGit(repo.repoPath);
+    const result = await git.raw(["ls-tree", "HEAD", "--", repo.relativePath]);
+    return result.trim().length === 0;
+  } catch {
+    return true;
+  }
+}
+async function getFileSummaries(cwd, files) {
+  if (files.length === 0) {
+    return [];
+  }
+  const summaries = [];
+  const filesByRepo = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const repo = await findGitRepo(cwd, file);
+    if (!repo) {
+      const group2 = filesByRepo.get(cwd) ?? [];
+      group2.push({ repoPath: cwd, relativePath: file, originalPath: file });
+      filesByRepo.set(cwd, group2);
+      continue;
+    }
+    const group = filesByRepo.get(repo.repoPath) ?? [];
+    group.push({
+      repoPath: repo.repoPath,
+      relativePath: repo.relativePath,
+      originalPath: file
+    });
+    filesByRepo.set(repo.repoPath, group);
+  }
+  for (const [repoPath, fileInfos] of filesByRepo) {
+    const git = simpleGit(repoPath);
+    const relativePaths = fileInfos.map((f) => f.relativePath);
+    try {
+      const stagedDiff = await git.diffSummary([
+        "--cached",
+        "--",
+        ...relativePaths
+      ]);
+      const unstagedDiff = await git.diffSummary(["--", ...relativePaths]);
+      const allDiffFiles = /* @__PURE__ */ new Map();
+      for (const file of unstagedDiff.files) {
+        allDiffFiles.set(file.file, file);
+      }
+      for (const file of stagedDiff.files) {
+        allDiffFiles.set(file.file, file);
+      }
+      for (const file of allDiffFiles.values()) {
+        const fileInfo = fileInfos.find((f) => f.relativePath === file.file);
+        if (!fileInfo) {
+          continue;
+        }
+        const isNew = await isNewFile(repoPath, file.file);
+        if (isTextFile(file)) {
+          summaries.push({
+            path: fileInfo.originalPath,
+            status: mapDiffStatus(file.insertions, file.deletions),
+            additions: file.insertions,
+            deletions: file.deletions,
+            binary: false,
+            isNewFile: isNew
+          });
+        } else {
+          summaries.push({
+            path: fileInfo.originalPath,
+            status: "modified",
+            additions: 0,
+            deletions: 0,
+            binary: true,
+            isNewFile: isNew
+          });
+        }
+      }
+      const processedPaths = new Set(
+        Array.from(allDiffFiles.values()).map((f) => f.file)
+      );
+      const missingInRepo = fileInfos.filter(
+        (f) => !processedPaths.has(f.relativePath)
+      );
+      for (const fileInfo of missingInRepo) {
+        summaries.push({
+          path: fileInfo.originalPath,
+          status: "added",
+          additions: 0,
+          deletions: 0,
+          binary: false,
+          isNewFile: true
+        });
+      }
+    } catch {
+      for (const fileInfo of fileInfos) {
+        summaries.push({
+          path: fileInfo.originalPath,
+          status: "modified",
+          additions: 0,
+          deletions: 0,
+          binary: false,
+          isNewFile: false
+          // Conservative assumption
+        });
+      }
+    }
+  }
+  return summaries;
+}
+function mapDiffStatus(insertions, deletions) {
+  if (deletions === 0 && insertions > 0) {
+    return "added";
+  }
+  if (insertions === 0 && deletions > 0) {
+    return "deleted";
+  }
+  return "modified";
+}
+function formatFileSummary(summary) {
+  const stats = summary.binary ? "binary" : `+${summary.additions}/-${summary.deletions}`;
+  return `${summary.path} (${summary.status}, ${stats})`;
+}
+async function getFileDiffs(cwd, files) {
+  if (files.length === 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  const diffs = /* @__PURE__ */ new Map();
+  const filesByRepo = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const repo = await findGitRepo(cwd, file);
+    if (!repo) {
+      const group2 = filesByRepo.get(cwd) ?? [];
+      group2.push({ repoPath: cwd, relativePath: file, originalPath: file });
+      filesByRepo.set(cwd, group2);
+      continue;
+    }
+    const group = filesByRepo.get(repo.repoPath) ?? [];
+    group.push({
+      repoPath: repo.repoPath,
+      relativePath: repo.relativePath,
+      originalPath: file
+    });
+    filesByRepo.set(repo.repoPath, group);
+  }
+  for (const [repoPath, fileInfos] of filesByRepo) {
+    const git = simpleGit(repoPath);
+    for (const { relativePath, originalPath } of fileInfos) {
+      try {
+        let diff = await git.diff(["--cached", "--", relativePath]);
+        if (!diff) {
+          diff = await git.diff(["--", relativePath]);
+        }
+        if (!diff) {
+          diff = await git.show([`:${relativePath}`]).catch(() => "");
+        }
+        if (diff) {
+          diffs.set(originalPath, diff);
+        }
+      } catch {
+      }
+    }
+  }
+  return diffs;
+}
+async function existsAsync(path) {
+  try {
+    const { existsSync } = await import('fs');
+    return existsSync(path);
+  } catch {
+    return false;
+  }
+}
+async function findGitRepo(basePath, filePath) {
+  const segments = filePath.split("/");
+  for (let i = segments.length - 1; i > 0; i--) {
+    const potentialRepoSegments = segments.slice(0, i);
+    const potentialRepoPath = `${basePath}/${potentialRepoSegments.join("/")}`;
+    const gitDir = `${potentialRepoPath}/.git`;
+    if (await existsAsync(gitDir)) {
+      const relativePath = segments.slice(i).join("/");
+      return { repoPath: potentialRepoPath, relativePath };
+    }
+  }
+  if (await existsAsync(`${basePath}/.git`)) {
+    return { repoPath: basePath, relativePath: filePath };
+  }
+  return null;
+}
+async function getFileDiff(cwd, filePath) {
+  const git = simpleGit(cwd);
+  const diffOutput = await git.diff(["HEAD", "--", filePath]);
+  const additions = (diffOutput.match(/^\+(?!\+)/gm) || []).length;
+  const deletions = (diffOutput.match(/^-(?!-)/gm) || []).length;
+  return {
+    diff: diffOutput,
+    additions,
+    deletions
+  };
+}
+async function getRecentCommits(cwd, count = 10) {
+  const git = simpleGit(cwd);
+  try {
+    const log = await git.log({
+      maxCount: count,
+      format: {
+        message: "%s"
+        // Subject line only
+      }
+    });
+    return log.all.map((commit) => commit.message);
+  } catch {
+    return [];
+  }
+}
+function detectCommitStyle(commits) {
+  if (commits.length === 0) {
+    return {
+      usesConventional: false,
+      commonScopes: [],
+      avgLength: 50
+    };
+  }
+  const conventionalPattern = /^(feat|fix|docs|style|refactor|test|chore|ci|perf|build)(\([^)]+\))?!?:/i;
+  const conventionalMatches = commits.filter(
+    (c) => conventionalPattern.test(c)
+  );
+  const usesConventional = conventionalMatches.length >= commits.length * 0.5;
+  const scopePattern = /^\w+\(([^)]+)\)/;
+  const scopes = commits.map((c) => {
+    const match = c.match(scopePattern);
+    return match ? match[1] : null;
+  }).filter((s) => s !== null);
+  const scopeCounts = scopes.reduce((acc, scope) => {
+    acc[scope] = (acc[scope] || 0) + 1;
+    return acc;
+  }, {});
+  const commonScopes = Object.entries(scopeCounts).sort((a, b) => b[1] - a[1]).slice(0, 5).map(([scope]) => scope);
+  const avgLength = Math.round(
+    commits.reduce((sum, c) => sum + c.length, 0) / commits.length
+  );
+  return {
+    usesConventional,
+    commonScopes,
+    avgLength
+  };
+}
+async function resolveScope(cwd, scope) {
+  const isExactPackageName = !scope.includes("*") && (scope.startsWith("@") || !scope.includes("/"));
+  const isWildcardPackageName = scope.includes("*") && (scope.startsWith("@") || !scope.includes("/"));
+  scope.includes("/") && !scope.startsWith("@");
+  if (isExactPackageName) {
+    const packages = await discoverPackages(cwd);
+    const matched = packages.filter((pkg) => pkg.name === scope);
+    return {
+      original: scope,
+      type: "package-name",
+      packagePaths: matched.map((p) => p.path),
+      filePattern: matched.length > 0 ? createGlobPattern(cwd, matched) : void 0
+    };
+  }
+  if (isWildcardPackageName) {
+    const packages = await discoverPackages(cwd);
+    const regex = createPackageNameRegex(scope);
+    const matched = packages.filter((pkg) => regex.test(pkg.name));
+    return {
+      original: scope,
+      type: "wildcard",
+      packagePaths: matched.map((p) => p.path),
+      filePattern: matched.length > 0 ? createGlobPattern(cwd, matched) : void 0
+    };
+  }
+  const filePattern = !scope.includes("*") && !scope.includes("?") ? `${scope}/**` : scope;
+  return {
+    original: scope,
+    type: "path-pattern",
+    packagePaths: [],
+    filePattern
+  };
+}
+function matchesScope(filePath, resolvedScope) {
+  if (resolvedScope.packagePaths.length > 0) {
+    return resolvedScope.packagePaths.some((pkgPath) => {
+      const normalizedFile = filePath.replace(/\\/g, "/");
+      const normalizedPkg = pkgPath.replace(/\\/g, "/");
+      return normalizedFile.startsWith(normalizedPkg + "/") || normalizedFile === normalizedPkg;
+    });
+  }
+  return true;
+}
+async function discoverPackages(cwd) {
+  const packages = [];
+  const packageJsonPaths = await globby("**/package.json", {
+    cwd,
+    absolute: true,
+    onlyFiles: true,
+    ignore: [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/.git/**",
+      "**/.*/**"
+    ]
+  });
+  for (const packageJsonPath of packageJsonPaths) {
+    try {
+      const packagePath = join(packageJsonPath, "..");
+      const content = await readFile(packageJsonPath, "utf-8");
+      const packageJson = JSON.parse(content);
+      if (!packageJson.name) {
+        continue;
+      }
+      packages.push({
+        name: packageJson.name,
+        path: relative(cwd, packagePath) || "."
+      });
+    } catch {
+    }
+  }
+  return packages;
+}
+function createPackageNameRegex(pattern) {
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`);
+}
+function createGlobPattern(cwd, packages) {
+  if (packages.length === 1 && packages[0]) {
+    return `${packages[0].path}/**`;
+  }
+  const paths = packages.map((p) => p.path).join(",");
+  return `{${paths}}/**`;
+}
+var SecretsDetectedError = class _SecretsDetectedError extends Error {
+  secretMatches;
+  constructor(matches, message) {
+    super(message);
+    this.name = "SecretsDetectedError";
+    this.secretMatches = matches;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _SecretsDetectedError);
+    }
+  }
+};
+var SECRET_FILE_PATTERNS = [
+  // Environment files
+  ".env",
+  ".env.*",
+  "*.env",
+  ".envrc",
+  // NPM/Node
+  ".npmrc",
+  ".yarnrc",
+  ".yarnrc.yml",
+  // SSH/GPG keys
+  "*.key",
+  "*.pem",
+  "*.p12",
+  "*.pfx",
+  "id_rsa",
+  "id_dsa",
+  "id_ecdsa",
+  "id_ed25519",
+  "*.pub",
+  // AWS
+  ".aws/**",
+  "credentials",
+  // Docker
+  ".docker/config.json",
+  // Git credentials
+  ".git-credentials",
+  ".netrc",
+  // Service account files
+  "*-service-account.json",
+  "*-serviceaccount.json",
+  "service-account*.json",
+  "serviceaccount*.json",
+  // Kubernetes
+  "kubeconfig",
+  "*.kubeconfig",
+  // Terraform
+  "*.tfvars",
+  "terraform.tfstate",
+  "terraform.tfstate.backup",
+  // Other common secrets
+  "secrets.yml",
+  "secrets.yaml",
+  "secret.yml",
+  "secret.yaml",
+  "passwords.txt",
+  "password.txt"
+];
+var SECRET_CONTENT_PATTERNS = [
+  // API keys/tokens
+  { pattern: /api[_-]?key[s]?['":\s]*[a-zA-Z0-9_-]{20,}/i, name: "API Key" },
+  { pattern: /auth[_-]?token[s]?['":\s]*[a-zA-Z0-9_-]{20,}/i, name: "Auth Token" },
+  { pattern: /access[_-]?token[s]?['":\s]*[a-zA-Z0-9_-]{20,}/i, name: "Access Token" },
+  // AWS
+  { pattern: /AKIA[0-9A-Z]{16}/, name: "AWS Access Key ID" },
+  { pattern: /aws[_-]?secret[_-]?access[_-]?key/i, name: "AWS Secret Access Key" },
+  // NPM
+  { pattern: /\/\/registry\.npmjs\.org\/:_authToken=/, name: "NPM Auth Token" },
+  { pattern: /npm_[A-Za-z0-9]{30,}/, name: "NPM Token" },
+  // GitHub
+  { pattern: /gh[pousr]_[A-Za-z0-9_]{36,}/, name: "GitHub Token" },
+  // Slack
+  { pattern: /xox[baprs]-[0-9]{10,13}-[0-9]{10,13}-[A-Za-z0-9]{24,}/, name: "Slack Token" },
+  // Private keys
+  { pattern: /-----BEGIN (RSA|DSA|EC|OPENSSH|PGP) PRIVATE KEY-----/, name: "Private Key" },
+  // Passwords
+  { pattern: /password['":\s]*['"]/i, name: "Password" },
+  // Generic patterns
+  { pattern: /secret['":\s]*['"]/i, name: "Secret" }
+];
+function isSecretFile(filePath) {
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  return SECRET_FILE_PATTERNS.some(
+    (pattern) => minimatch(normalizedPath, pattern, { matchBase: true })
+  );
+}
+function containsSecrets(content) {
+  return SECRET_CONTENT_PATTERNS.some(({ pattern }) => pattern.test(content));
+}
+function detectSecretFiles(files) {
+  return files.filter(isSecretFile);
+}
+function detectSecretsInDiffs(diffs) {
+  const secretDiffs = /* @__PURE__ */ new Map();
+  for (const [file, diff] of diffs.entries()) {
+    if (containsSecrets(diff)) {
+      secretDiffs.set(file, diff);
+    }
+  }
+  return secretDiffs;
+}
+function formatSecretsWarning(secretFiles) {
+  const count = secretFiles.length;
+  const filesList = secretFiles.map((f) => `  - ${f}`).join("\n");
+  return [
+    `\u{1F6A8} CRITICAL SECURITY ERROR: Detected ${count} file(s) with potential secrets:`,
+    filesList,
+    "",
+    "\u26D4\uFE0F COMMIT GENERATION ABORTED",
+    "",
+    "These files contain sensitive data (API keys, tokens, credentials)",
+    "that MUST NOT be committed to git or sent to LLM.",
+    "",
+    "\u2705 Actions to fix:",
+    "  1. Add these files to .gitignore",
+    "  2. Remove secrets from the files (use environment variables instead)",
+    "  3. If already committed, use git filter-branch or BFG to remove from history",
+    "",
+    "\u26A0\uFE0F  If you already ran commit:generate before, the secrets may have been",
+    "sent to OpenAI. Rotate your credentials immediately."
+  ].join("\n");
+}
+function detectSecretsWithLocation(diffs) {
+  const matches = [];
+  for (const [file, diff] of diffs.entries()) {
+    const lines = diff.split("\n");
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+      const line = lines[lineIndex] ?? "";
+      for (const { pattern, name } of SECRET_CONTENT_PATTERNS) {
+        pattern.lastIndex = 0;
+        const match = pattern.exec(line);
+        if (match) {
+          const matchedText = match[0];
+          const column = match.index;
+          const snippetStart = Math.max(0, column - 20);
+          const snippetEnd = Math.min(line.length, column + matchedText.length + 20);
+          const snippet = line.substring(snippetStart, snippetEnd);
+          const displayText = matchedText.length > 50 ? matchedText.substring(0, 50) + "..." : matchedText;
+          matches.push({
+            file,
+            line: lineIndex + 1,
+            // 1-based line numbers
+            column: column + 1,
+            // 1-based column numbers
+            pattern: pattern.source,
+            patternName: name,
+            snippet: snippet.trim(),
+            matchedText: displayText
+          });
+        }
+      }
+    }
+  }
+  return matches;
+}
+function formatSecretsReport(matches) {
+  const count = matches.length;
+  const fileCount = new Set(matches.map((m) => m.file)).size;
+  const lines = [
+    `\u{1F6A8} CRITICAL SECURITY ERROR: Detected ${count} potential secret(s) in ${fileCount} file(s)`,
+    "",
+    "\u26D4\uFE0F COMMIT GENERATION BLOCKED",
+    ""
+  ];
+  const byFile = /* @__PURE__ */ new Map();
+  for (const match of matches) {
+    const existing = byFile.get(match.file) ?? [];
+    existing.push(match);
+    byFile.set(match.file, existing);
+  }
+  for (const [file, fileMatches] of byFile.entries()) {
+    lines.push(`\u{1F4C4} ${file}:`);
+    for (const match of fileMatches) {
+      lines.push(`  Line ${match.line}:${match.column} - ${match.patternName}`);
+      lines.push(`    Pattern: ${match.pattern.substring(0, 60)}${match.pattern.length > 60 ? "..." : ""}`);
+      lines.push(`    Matched: ${match.matchedText}`);
+      lines.push(`    Context: ...${match.snippet}...`);
+      lines.push("");
+    }
+  }
+  lines.push(
+    "\u{1F512} These files contain sensitive data (API keys, tokens, credentials)",
+    "that MUST NOT be committed to git or sent to LLM.",
+    "",
+    "\u2705 Actions to fix:",
+    "  1. Review each match above - some may be false positives (e.g., examples in comments)",
+    "  2. If real secrets: Add files to .gitignore and remove secrets (use env vars)",
+    "  3. If false positives: Use --allow-secrets flag to proceed with confirmation",
+    "",
+    "\u26A0\uFE0F  If secrets were already sent to LLM in previous runs, rotate credentials immediately!"
+  );
+  return lines.join("\n");
+}
+
+export { SecretsDetectedError, containsSecrets, detectCommitStyle, detectSecretFiles, detectSecretsInDiffs, detectSecretsWithLocation, formatFileSummary, formatSecretsReport, formatSecretsWarning, getAllChangedFiles, getCurrentBranch, getFileDiff, getFileDiffs, getFileSummaries, getGitStatus, getRecentCommits, hasChanges, isProtectedBranch, isSecretFile, matchesScope, resolveScope };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map