javi-forge 1.6.0 → 1.7.0

package/dist/lib/plugin.js

@@ -1,10 +1,9 @@
-import fs from 'fs-extra';
-import path from 'path';
-import { execFile } from 'child_process';
-import { promisify } from 'util';
-import { PLUGINS_DIR, PLUGIN_MANIFEST_FILE, PLUGIN_ASSET_DIRS, PLUGIN_REGISTRY_URL } from '../constants.js';
-import { generateAgentSkillsManifest } from './agent-skills.js';
-const execFileAsync = promisify(execFile);
+import path from "node:path";
+import fs from "fs-extra";
+import { PLUGIN_ASSET_DIRS, PLUGIN_MANIFEST_FILE, PLUGIN_REGISTRY_URL, PLUGINS_DIR, } from "../constants.js";
+import { generateAgentSkillsManifest } from "./agent-skills.js";
+import { autoWirePlugins } from "./auto-wire.js";
+import { execFileAsync } from "./exec.js";
 const KEBAB_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
 const SEMVER_RE = /^\d+\.\d+\.\d+$/;
 // ── Validation ──────────────────────────────────────────────────────────────
@@ -15,49 +14,60 @@ export async function validatePlugin(pluginDir) {
     const errors = [];
     // Check plugin.json exists
     const manifestPath = path.join(pluginDir, PLUGIN_MANIFEST_FILE);
-    if (!await fs.pathExists(manifestPath)) {
+    if (!(await fs.pathExists(manifestPath))) {
         return {
             valid: false,
-            errors: [{ path: PLUGIN_MANIFEST_FILE, message: 'plugin.json not found' }],
+            errors: [
+                { path: PLUGIN_MANIFEST_FILE, message: "plugin.json not found" },
+            ],
             manifest: null,
         };
     }
     // Parse manifest
     let manifest;
     try {
-        manifest = await fs.readJson(manifestPath);
+        manifest = (await fs.readJson(manifestPath));
     }
     catch {
         return {
             valid: false,
-            errors: [{ path: PLUGIN_MANIFEST_FILE, message: 'invalid JSON' }],
+            errors: [{ path: PLUGIN_MANIFEST_FILE, message: "invalid JSON" }],
             manifest: null,
         };
     }
     // Validate required fields
-    if (typeof manifest.name !== 'string' || !manifest.name) {
-        errors.push({ path: 'name', message: 'name is required' });
+    if (typeof manifest.name !== "string" || !manifest.name) {
+        errors.push({ path: "name", message: "name is required" });
     }
     else if (!KEBAB_RE.test(manifest.name)) {
-        errors.push({ path: 'name', message: 'name must be kebab-case' });
+        errors.push({ path: "name", message: "name must be kebab-case" });
     }
     else if (manifest.name.length < 2 || manifest.name.length > 60) {
-        errors.push({ path: 'name', message: 'name must be 2-60 characters' });
+        errors.push({ path: "name", message: "name must be 2-60 characters" });
     }
-    if (typeof manifest.version !== 'string' || !manifest.version) {
-        errors.push({ path: 'version', message: 'version is required' });
+    if (typeof manifest.version !== "string" || !manifest.version) {
+        errors.push({ path: "version", message: "version is required" });
     }
     else if (!SEMVER_RE.test(manifest.version)) {
-        errors.push({ path: 'version', message: 'version must be semver (e.g. 1.0.0)' });
+        errors.push({
+            path: "version",
+            message: "version must be semver (e.g. 1.0.0)",
+        });
     }
-    if (typeof manifest.description !== 'string' || !manifest.description) {
-        errors.push({ path: 'description', message: 'description is required' });
+    if (typeof manifest.description !== "string" || !manifest.description) {
+        errors.push({ path: "description", message: "description is required" });
     }
     else if (manifest.description.length < 10) {
-        errors.push({ path: 'description', message: 'description must be at least 10 characters' });
+        errors.push({
+            path: "description",
+            message: "description must be at least 10 characters",
+        });
     }
     else if (manifest.description.length > 200) {
-        errors.push({ path: 'description', message: 'description must be at most 200 characters' });
+        errors.push({
+            path: "description",
+            message: "description must be at most 200 characters",
+        });
     }
     // Validate asset directories actually exist when declared
     for (const assetType of PLUGIN_ASSET_DIRS) {
@@ -65,26 +75,36 @@ export async function validatePlugin(pluginDir) {
         if (!Array.isArray(declared) || declared.length === 0)
             continue;
         const assetDir = path.join(pluginDir, assetType);
-        if (!await fs.pathExists(assetDir)) {
-            errors.push({ path: assetType, message: `declared ${assetType}/ directory not found` });
+        if (!(await fs.pathExists(assetDir))) {
+            errors.push({
+                path: assetType,
+                message: `declared ${assetType}/ directory not found`,
+            });
             continue;
         }
         // Check each declared asset exists
         for (const entry of declared) {
             const entryPath = path.join(assetDir, entry);
-            if (!await fs.pathExists(entryPath)) {
-                errors.push({ path: `${assetType}/${entry}`, message: `declared entry not found` });
+            if (!(await fs.pathExists(entryPath))) {
+                errors.push({
+                    path: `${assetType}/${entry}`,
+                    message: `declared entry not found`,
+                });
             }
         }
     }
     // Validate tags
     if (manifest.tags && !Array.isArray(manifest.tags)) {
-        errors.push({ path: 'tags', message: 'tags must be an array' });
+        errors.push({ path: "tags", message: "tags must be an array" });
     }
     else if (manifest.tags && manifest.tags.length > 10) {
-        errors.push({ path: 'tags', message: 'max 10 tags allowed' });
+        errors.push({ path: "tags", message: "max 10 tags allowed" });
     }
-    return { valid: errors.length === 0, errors, manifest: errors.length === 0 ? manifest : manifest };
+    return {
+        valid: errors.length === 0,
+        errors,
+        manifest: errors.length === 0 ? manifest : manifest,
+    };
 }
 // ── Installation ────────────────────────────────────────────────────────────
 /**
@@ -96,23 +116,36 @@ export async function installPlugin(source, options = {}) {
     // Normalize source to a git URL
     const gitUrl = normalizeGitUrl(source);
     if (!gitUrl) {
-        return { success: false, error: `invalid source: ${source}. Use org/repo or a GitHub URL` };
+        return {
+            success: false,
+            error: `invalid source: ${source}. Use org/repo or a GitHub URL`,
+        };
     }
     // Clone to temp
-    const tmpDir = path.join(PLUGINS_DIR, '.tmp', `install-${Date.now()}`);
+    const tmpDir = path.join(PLUGINS_DIR, ".tmp", `install-${Date.now()}`);
     try {
         if (!dryRun) {
             await fs.ensureDir(tmpDir);
-            await execFileAsync('git', ['clone', '--depth', '1', gitUrl, tmpDir], {
+            await execFileAsync("git", ["clone", "--depth", "1", gitUrl, tmpDir], {
                 timeout: 60_000,
             });
         }
         // Validate
         const validation = dryRun
-            ? { valid: true, errors: [], manifest: { name: source.split('/').pop() ?? 'unknown', version: '0.0.0', description: 'dry-run placeholder' } }
+            ? {
+                valid: true,
+                errors: [],
+                manifest: {
+                    name: source.split("/").pop() ?? "unknown",
+                    version: "0.0.0",
+                    description: "dry-run placeholder",
+                },
+            }
             : await validatePlugin(tmpDir);
         if (!validation.valid || !validation.manifest) {
-            const msgs = validation.errors.map(e => `  ${e.path}: ${e.message}`).join('\n');
+            const msgs = validation.errors
+                .map((e) => `  ${e.path}: ${e.message}`)
+                .join("\n");
             return { success: false, error: `validation failed:\n${msgs}` };
         }
         const pluginName = validation.manifest.name;
@@ -131,7 +164,7 @@ export async function installPlugin(source, options = {}) {
                 source,
                 manifest: validation.manifest,
             };
-            await fs.writeJson(path.join(destDir, '.installed.json'), installedPlugin, { spaces: 2 });
+            await fs.writeJson(path.join(destDir, ".installed.json"), installedPlugin, { spaces: 2 });
             // Generate Agent Skills spec manifest for cross-agent compatibility
             await generateAgentSkillsManifest(destDir, source).catch(() => { });
         }
@@ -143,7 +176,7 @@ export async function installPlugin(source, options = {}) {
     }
     finally {
         // Clean up tmp if it still exists (error path)
-        if (!dryRun && await fs.pathExists(tmpDir)) {
+        if (!dryRun && (await fs.pathExists(tmpDir))) {
             await fs.remove(tmpDir).catch(() => { });
         }
     }
@@ -153,7 +186,7 @@ export async function installPlugin(source, options = {}) {
  */
 export async function removePlugin(name, options = {}) {
     const pluginDir = path.join(PLUGINS_DIR, name);
-    if (!await fs.pathExists(pluginDir)) {
+    if (!(await fs.pathExists(pluginDir))) {
         return { success: false, error: `plugin "${name}" is not installed` };
     }
     if (!options.dryRun) {
@@ -166,20 +199,22 @@ export async function removePlugin(name, options = {}) {
  * List all installed plugins.
  */
 export async function listInstalledPlugins() {
-    if (!await fs.pathExists(PLUGINS_DIR))
+    if (!(await fs.pathExists(PLUGINS_DIR)))
         return [];
     const entries = await fs.readdir(PLUGINS_DIR);
     const plugins = [];
     for (const entry of entries) {
-        if (entry.startsWith('.'))
+        if (entry.startsWith("."))
             continue;
-        const metaPath = path.join(PLUGINS_DIR, entry, '.installed.json');
+        const metaPath = path.join(PLUGINS_DIR, entry, ".installed.json");
         if (await fs.pathExists(metaPath)) {
             try {
-                const meta = await fs.readJson(metaPath);
+                const meta = (await fs.readJson(metaPath));
                 plugins.push(meta);
             }
-            catch { /* skip corrupt entries */ }
+            catch {
+                /* skip corrupt entries */
+            }
         }
     }
     return plugins;
@@ -193,13 +228,13 @@ export async function searchRegistry(query) {
         if (!response.ok) {
             return [];
         }
-        const registry = await response.json();
+        const registry = (await response.json());
         let plugins = registry.plugins ?? [];
         if (query) {
             const q = query.toLowerCase();
-            plugins = plugins.filter(p => p.id.toLowerCase().includes(q) ||
+            plugins = plugins.filter((p) => p.id.toLowerCase().includes(q) ||
                 p.description.toLowerCase().includes(q) ||
-                p.tags.some(t => t.toLowerCase().includes(q)));
+                p.tags.some((t) => t.toLowerCase().includes(q)));
         }
         return plugins;
     }
@@ -213,47 +248,59 @@ export async function searchRegistry(query) {
  * Returns an array of plugin names (sorted alphabetically).
  */
 export async function detectProjectPlugins(projectDir) {
-    const pluginsDir = path.join(projectDir, '.javi-forge', 'plugins');
-    if (!await fs.pathExists(pluginsDir))
+    const full = await detectProjectPluginsFull(projectDir);
+    return full.map((p) => p.name).sort();
+}
+/**
+ * Detect installed plugins with full metadata (including manifest).
+ * Used by auto-wiring to read plugin capabilities.
+ */
+export async function detectProjectPluginsFull(projectDir) {
+    const pluginsDir = path.join(projectDir, ".javi-forge", "plugins");
+    if (!(await fs.pathExists(pluginsDir)))
         return [];
     const entries = await fs.readdir(pluginsDir);
     const plugins = [];
     for (const entry of entries) {
-        if (entry.startsWith('.'))
+        if (entry.startsWith("."))
             continue;
-        const metaPath = path.join(pluginsDir, entry, '.installed.json');
+        const metaPath = path.join(pluginsDir, entry, ".installed.json");
         if (await fs.pathExists(metaPath)) {
             try {
-                const meta = await fs.readJson(metaPath);
+                const meta = (await fs.readJson(metaPath));
                 if (meta.name) {
-                    plugins.push(meta.name);
+                    plugins.push(meta);
                 }
             }
-            catch { /* skip corrupt entries */ }
+            catch {
+                /* skip corrupt entries */
+            }
         }
     }
-    return plugins.sort();
+    return plugins.sort((a, b) => a.name.localeCompare(b.name));
 }
 /**
- * Sync detected plugins into the project manifest.
- * Returns a report of added, removed, and unchanged plugins.
+ * Sync detected plugins into the project manifest and auto-wire
+ * their capabilities into CLAUDE.md and .claude/settings.json.
+ * Returns a report of added, removed, unchanged, wired, and unwired plugins.
  */
 export async function syncPlugins(projectDir, options = {}) {
     const { dryRun = false } = options;
-    const detected = await detectProjectPlugins(projectDir);
-    const manifestPath = path.join(projectDir, '.javi-forge', 'manifest.json');
+    const detectedFull = await detectProjectPluginsFull(projectDir);
+    const detected = detectedFull.map((p) => p.name).sort();
+    const manifestPath = path.join(projectDir, ".javi-forge", "manifest.json");
     let manifest;
     if (await fs.pathExists(manifestPath)) {
-        manifest = await fs.readJson(manifestPath);
+        manifest = (await fs.readJson(manifestPath));
     }
     else {
         // No manifest yet — treat current plugins as empty
         manifest = {
-            version: '0.1.0',
+            version: "0.1.0",
             projectName: path.basename(projectDir),
-            stack: 'node',
-            ciProvider: 'github',
-            memory: 'none',
+            stack: "node",
+            ciProvider: "github",
+            memory: "none",
             createdAt: new Date().toISOString(),
             updatedAt: new Date().toISOString(),
             modules: [],
@@ -261,16 +308,26 @@ export async function syncPlugins(projectDir, options = {}) {
     }
     const previous = new Set(manifest.plugins ?? []);
     const current = new Set(detected);
-    const added = detected.filter(p => !previous.has(p));
-    const removed = [...previous].filter(p => !current.has(p));
-    const unchanged = detected.filter(p => previous.has(p));
+    const added = detected.filter((p) => !previous.has(p));
+    const removed = [...previous].filter((p) => !current.has(p));
+    const unchanged = detected.filter((p) => previous.has(p));
     if (!dryRun && (added.length > 0 || removed.length > 0)) {
         manifest.plugins = detected;
         manifest.updatedAt = new Date().toISOString();
         await fs.ensureDir(path.dirname(manifestPath));
         await fs.writeJson(manifestPath, manifest, { spaces: 2 });
     }
-    return { added, removed, unchanged };
+    // ── Auto-wire plugin capabilities ──────────────────────────────────
+    const wireResult = await autoWirePlugins(projectDir, detectedFull, {
+        dryRun,
+    });
+    return {
+        added,
+        removed,
+        unchanged,
+        wired: wireResult.wired,
+        unwired: wireResult.unwired,
+    };
 }
 // ── Helpers ─────────────────────────────────────────────────────────────────
 /**
@@ -279,15 +336,15 @@ export async function syncPlugins(projectDir, options = {}) {
  */
 export function normalizeGitUrl(source) {
     // Already a full URL
-    if (source.startsWith('https://github.com/')) {
-        return source.endsWith('.git') ? source : `${source}.git`;
+    if (source.startsWith("https://github.com/")) {
+        return source.endsWith(".git") ? source : `${source}.git`;
     }
     // github.com/org/repo
-    if (source.startsWith('github.com/')) {
+    if (source.startsWith("github.com/")) {
         return `https://${source}.git`;
     }
     // org/repo shorthand
-    const parts = source.split('/');
+    const parts = source.split("/");
     if (parts.length === 2 && parts[0] && parts[1]) {
         return `https://github.com/${parts[0]}/${parts[1]}.git`;
     }

package/dist/lib/secret-scanner.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Secret scanner — detects leaked credentials in source files using
+ * a curated regex bundle. Designed for pre-commit hooks and CI gates.
+ */
+export interface SecretPattern {
+    id: string;
+    label: string;
+    pattern: RegExp;
+    severity: "critical" | "high" | "medium";
+}
+export interface SecretFinding {
+    patternId: string;
+    label: string;
+    severity: SecretPattern["severity"];
+    file: string;
+    line: number;
+    match: string;
+}
+export interface ScanResult {
+    findings: SecretFinding[];
+    filesScanned: number;
+    patternsUsed: number;
+}
+export declare const SECRET_PATTERNS: SecretPattern[];
+export declare function maskSecret(value: string): string;
+export declare function shouldScanFile(filePath: string): boolean;
+export declare function shouldSkipDir(dirName: string): boolean;
+export declare function scanContent(content: string, filePath: string, patterns?: SecretPattern[]): SecretFinding[];
+export declare function scanDirectory(dir: string, patterns?: SecretPattern[]): Promise<ScanResult>;
+//# sourceMappingURL=secret-scanner.d.ts.map

package/dist/lib/secret-scanner.js

@@ -0,0 +1,274 @@
+/**
+ * Secret scanner — detects leaked credentials in source files using
+ * a curated regex bundle. Designed for pre-commit hooks and CI gates.
+ */
+import path from "node:path";
+import fs from "fs-extra";
+// ── Regex Bundle ──
+export const SECRET_PATTERNS = [
+    // AWS
+    {
+        id: "aws-access-key",
+        label: "AWS Access Key ID",
+        pattern: /\bAKIA[0-9A-Z]{16}\b/,
+        severity: "critical",
+    },
+    {
+        id: "aws-secret-key",
+        label: "AWS Secret Access Key",
+        pattern: /(?<![A-Za-z0-9/+=])[A-Za-z0-9/+=]{40}(?![A-Za-z0-9/+=])/,
+        severity: "critical",
+    },
+    // Google
+    {
+        id: "gcp-api-key",
+        label: "Google API Key",
+        pattern: /\bAIza[0-9A-Za-z_-]{35}\b/,
+        severity: "high",
+    },
+    {
+        id: "gcp-oauth",
+        label: "Google OAuth Client Secret",
+        pattern: /\bGOCSPX-[A-Za-z0-9_-]{28}\b/,
+        severity: "critical",
+    },
+    {
+        id: "gcp-sa-key",
+        label: "GCP Service Account Key",
+        pattern: /"type":\s*"service_account"/,
+        severity: "critical",
+    },
+    // GitHub
+    {
+        id: "github-pat",
+        label: "GitHub Personal Access Token",
+        pattern: /\bghp_[A-Za-z0-9]{36}\b/,
+        severity: "critical",
+    },
+    {
+        id: "github-oauth",
+        label: "GitHub OAuth Token",
+        pattern: /\bgho_[A-Za-z0-9]{36}\b/,
+        severity: "critical",
+    },
+    {
+        id: "github-app-token",
+        label: "GitHub App Token",
+        pattern: /\bghu_[A-Za-z0-9]{36}\b/,
+        severity: "high",
+    },
+    {
+        id: "github-fine-pat",
+        label: "GitHub Fine-Grained PAT",
+        pattern: /\bgithub_pat_[A-Za-z0-9]{22}_[A-Za-z0-9]{59}\b/,
+        severity: "critical",
+    },
+    // Stripe
+    {
+        id: "stripe-secret",
+        label: "Stripe Secret Key",
+        pattern: /\bsk_live_[A-Za-z0-9]{24,}\b/,
+        severity: "critical",
+    },
+    {
+        id: "stripe-restricted",
+        label: "Stripe Restricted Key",
+        pattern: /\brk_live_[A-Za-z0-9]{24,}\b/,
+        severity: "critical",
+    },
+    // Slack
+    {
+        id: "slack-bot-token",
+        label: "Slack Bot Token",
+        pattern: /\bxoxb-[0-9]{10,}-[0-9]{10,}-[A-Za-z0-9]{24,}\b/,
+        severity: "high",
+    },
+    {
+        id: "slack-webhook",
+        label: "Slack Webhook URL",
+        pattern: /https:\/\/hooks\.slack\.com\/services\/T[A-Z0-9]+\/B[A-Z0-9]+\/[A-Za-z0-9]+/,
+        severity: "high",
+    },
+    // Generic
+    {
+        id: "private-key",
+        label: "Private Key",
+        pattern: /-----BEGIN (?:RSA |EC |DSA |OPENSSH )?PRIVATE KEY-----/,
+        severity: "critical",
+    },
+    {
+        id: "jwt-token",
+        label: "JSON Web Token",
+        pattern: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/,
+        severity: "high",
+    },
+    {
+        id: "bearer-token",
+        label: "Bearer Token",
+        pattern: /[Bb]earer\s+[A-Za-z0-9_-]{20,}/,
+        severity: "medium",
+    },
+    {
+        id: "password-assign",
+        label: "Password Assignment",
+        pattern: /(?:password|passwd|pwd|secret)\s*[:=]\s*['"][^'"]{8,}['"]/,
+        severity: "high",
+    },
+    // Cloud providers
+    {
+        id: "azure-connection",
+        label: "Azure Connection String",
+        pattern: /DefaultEndpointsProtocol=https;AccountName=[^;]+;AccountKey=[A-Za-z0-9+/=]+/,
+        severity: "critical",
+    },
+    {
+        id: "sendgrid-key",
+        label: "SendGrid API Key",
+        pattern: /\bSG\.[A-Za-z0-9_-]{22}\.[A-Za-z0-9_-]{43}\b/,
+        severity: "high",
+    },
+    {
+        id: "twilio-key",
+        label: "Twilio API Key",
+        pattern: /\bSK[0-9a-fA-F]{32}\b/,
+        severity: "high",
+    },
+    // Database
+    {
+        id: "db-connection",
+        label: "Database Connection String",
+        pattern: /(?:mongodb|postgres|mysql|redis):\/\/[^:\s]+:[^@\s]+@[^\s]+/,
+        severity: "critical",
+    },
+    // Anthropic / OpenAI
+    {
+        id: "anthropic-key",
+        label: "Anthropic API Key",
+        pattern: /\bsk-ant-api03-[A-Za-z0-9_-]{93}\b/,
+        severity: "critical",
+    },
+    {
+        id: "openai-key",
+        label: "OpenAI API Key",
+        pattern: /\bsk-[A-Za-z0-9]{48,}\b/,
+        severity: "critical",
+    },
+];
+// ── Masking ──
+export function maskSecret(value) {
+    if (value.length <= 8)
+        return "****";
+    return `${value.slice(0, 4)}...${value.slice(-2)}`;
+}
+// ── File filtering ──
+const BINARY_EXTENSIONS = new Set([
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".ico",
+    ".svg",
+    ".woff",
+    ".woff2",
+    ".ttf",
+    ".eot",
+    ".mp3",
+    ".mp4",
+    ".zip",
+    ".gz",
+    ".tar",
+    ".pdf",
+    ".exe",
+    ".dll",
+    ".so",
+    ".dylib",
+    ".o",
+    ".a",
+]);
+const SKIP_DIRS = new Set([
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    ".next",
+    "__pycache__",
+    "target",
+    "vendor",
+    ".venv",
+    "venv",
+    ".tox",
+    ".mypy_cache",
+    "coverage",
+    ".nyc_output",
+    ".cache",
+]);
+export function shouldScanFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (BINARY_EXTENSIONS.has(ext))
+        return false;
+    if (filePath.includes("lock") && (ext === ".json" || ext === ".yaml"))
+        return false;
+    return true;
+}
+export function shouldSkipDir(dirName) {
+    return SKIP_DIRS.has(dirName);
+}
+// ── Scanner ──
+export function scanContent(content, filePath, patterns = SECRET_PATTERNS) {
+    const findings = [];
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line === undefined)
+            continue;
+        for (const pat of patterns) {
+            const match = pat.pattern.exec(line);
+            if (match) {
+                findings.push({
+                    patternId: pat.id,
+                    label: pat.label,
+                    severity: pat.severity,
+                    file: filePath,
+                    line: i + 1,
+                    match: maskSecret(match[0]),
+                });
+            }
+        }
+    }
+    return findings;
+}
+async function collectFiles(dir) {
+    const results = [];
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            if (!shouldSkipDir(entry.name)) {
+                results.push(...(await collectFiles(path.join(dir, entry.name))));
+            }
+        }
+        else if (entry.isFile() && shouldScanFile(entry.name)) {
+            results.push(path.join(dir, entry.name));
+        }
+    }
+    return results;
+}
+export async function scanDirectory(dir, patterns = SECRET_PATTERNS) {
+    const files = await collectFiles(dir);
+    const allFindings = [];
+    for (const file of files) {
+        try {
+            const content = await fs.readFile(file, "utf-8");
+            const rel = path.relative(dir, file);
+            allFindings.push(...scanContent(content, rel, patterns));
+        }
+        catch {
+            // Skip unreadable files
+        }
+    }
+    return {
+        findings: allFindings,
+        filesScanned: files.length,
+        patternsUsed: patterns.length,
+    };
+}
+//# sourceMappingURL=secret-scanner.js.map