javi-forge 1.6.0 → 1.6.1

package/dist/commands/llmstxt.d.ts

@@ -1,4 +1,4 @@
-import type { InitStep } from '../types/index.js';
+import type { InitStep } from "../types/index.js";
 type StepCallback = (step: InitStep) => void;
 /**
  * Generate an llms.txt file — compact AI-friendly project notation.

package/dist/commands/llmstxt.js

@@ -1,7 +1,7 @@
-import fs from 'fs-extra';
-import path from 'path';
-import { glob } from 'glob';
-import { detectStack } from '../lib/common.js';
+import fs from "fs-extra";
+import { glob } from "glob";
+import path from "path";
+import { detectStack } from "../lib/common.js";
 function report(onStep, id, label, status, detail) {
     onStep({ id, label, status, detail });
 }
@@ -10,53 +10,55 @@ function report(onStep, id, label, status, detail) {
  * Reduces token usage by ~75% compared to full README + docs.
  */
 export async function generateLlmsTxt(projectDir, dryRun, onStep) {
-    report(onStep, 'scan', 'Scan project structure', 'running');
+    report(onStep, "scan", "Scan project structure", "running");
     const detection = await detectStack(projectDir);
-    const stackLabel = detection?.stackType ?? 'unknown';
+    const stackLabel = detection?.stackType ?? "unknown";
     // Gather project info
     const name = path.basename(projectDir);
-    let description = '';
-    let version = '';
+    let description = "";
+    let version = "";
     let entryPoints = [];
     let dependencies = [];
     // Try package.json (Node)
-    const pkgPath = path.join(projectDir, 'package.json');
+    const pkgPath = path.join(projectDir, "package.json");
     if (await fs.pathExists(pkgPath)) {
         try {
             const pkg = await fs.readJson(pkgPath);
-            description = pkg.description ?? '';
-            version = pkg.version ?? '';
+            description = pkg.description ?? "";
+            version = pkg.version ?? "";
             entryPoints = pkg.main ? [pkg.main] : [];
             dependencies = Object.keys(pkg.dependencies ?? {}).slice(0, 15);
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
     }
     // Scan source files
-    const sourceFiles = await glob('src/**/*.{ts,tsx,js,jsx,py,go,rs}', {
+    const sourceFiles = await glob("src/**/*.{ts,tsx,js,jsx,py,go,rs}", {
         cwd: projectDir,
-        ignore: ['**/node_modules/**', '**/dist/**', '**/.git/**'],
+        ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"],
     });
     // Scan test files
-    const testFiles = await glob('**/*.{test,spec}.{ts,tsx,js,jsx,py}', {
+    const testFiles = await glob("**/*.{test,spec}.{ts,tsx,js,jsx,py}", {
         cwd: projectDir,
-        ignore: ['**/node_modules/**', '**/dist/**'],
+        ignore: ["**/node_modules/**", "**/dist/**"],
     });
-    report(onStep, 'scan', 'Scan project structure', 'done', `${sourceFiles.length} source, ${testFiles.length} test files`);
+    report(onStep, "scan", "Scan project structure", "done", `${sourceFiles.length} source, ${testFiles.length} test files`);
     // Build llms.txt content
-    report(onStep, 'generate', 'Generate llms.txt', 'running');
+    report(onStep, "generate", "Generate llms.txt", "running");
     const lines = [
         `# ${name}`,
-        '',
-        `> ${description || 'No description'}`,
-        '',
-        `- stack: ${stackLabel}${detection?.buildTool ? ` (${detection.buildTool})` : ''}`,
-        `- version: ${version || 'unknown'}`,
+        "",
+        `> ${description || "No description"}`,
+        "",
+        `- stack: ${stackLabel}${detection?.buildTool ? ` (${detection.buildTool})` : ""}`,
+        `- version: ${version || "unknown"}`,
         `- files: ${sourceFiles.length} source, ${testFiles.length} tests`,
-        '',
+        "",
     ];
     // Structure summary (compact)
     if (sourceFiles.length > 0) {
-        lines.push('## Structure');
+        lines.push("## Structure");
         const dirs = new Map();
         for (const f of sourceFiles) {
             const dir = path.dirname(f);
@@ -65,28 +67,28 @@ export async function generateLlmsTxt(projectDir, dryRun, onStep) {
         for (const [dir, count] of [...dirs.entries()].sort().slice(0, 20)) {
             lines.push(`- ${dir}/ (${count})`);
         }
-        lines.push('');
+        lines.push("");
     }
     // Dependencies (compact — name only, no versions)
     if (dependencies.length > 0) {
-        lines.push('## Dependencies');
-        lines.push(dependencies.join(', '));
-        lines.push('');
+        lines.push("## Dependencies");
+        lines.push(dependencies.join(", "));
+        lines.push("");
     }
     // Entry points
     if (entryPoints.length > 0) {
-        lines.push('## Entry');
+        lines.push("## Entry");
         for (const ep of entryPoints) {
             lines.push(`- ${ep}`);
         }
-        lines.push('');
+        lines.push("");
     }
-    const content = lines.join('\n');
+    const content = lines.join("\n");
     const tokenEstimate = Math.ceil(content.length / 4);
     if (!dryRun) {
-        await fs.writeFile(path.join(projectDir, 'llms.txt'), content, 'utf-8');
+        await fs.writeFile(path.join(projectDir, "llms.txt"), content, "utf-8");
     }
-    report(onStep, 'generate', 'Generate llms.txt', 'done', dryRun
+    report(onStep, "generate", "Generate llms.txt", "done", dryRun
         ? `dry-run: ~${tokenEstimate} tokens (${content.length} chars)`
         : `written — ~${tokenEstimate} tokens (${content.length} chars)`);
 }

package/dist/commands/parallel-batch.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Parallel batch sub-agents — spawn test/lint/build runners per module
+ * in parallel during quality scoring. Collects results and aggregates.
+ */
+export type JobStatus = "pending" | "running" | "done" | "error";
+export interface BatchJob {
+    id: string;
+    name: string;
+    command: string;
+    module: string;
+    status: JobStatus;
+    startedAt: number | null;
+    completedAt: number | null;
+    durationMs: number;
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+}
+export interface BatchResult {
+    jobs: BatchJob[];
+    totalDurationMs: number;
+    passedCount: number;
+    failedCount: number;
+    parallelism: number;
+}
+export interface BatchConfig {
+    maxParallel: number;
+    timeoutMs: number;
+}
+export declare const DEFAULT_BATCH_CONFIG: BatchConfig;
+export declare function createJob(name: string, command: string, module: string): BatchJob;
+export type JobExecutor = (job: BatchJob) => Promise<BatchJob>;
+/**
+ * Default executor — runs command via child_process.
+ */
+export declare function createShellExecutor(timeoutMs?: number): JobExecutor;
+/**
+ * Run jobs in parallel with configurable concurrency.
+ */
+export declare function runBatch(jobs: BatchJob[], executor: JobExecutor, config?: BatchConfig): Promise<BatchResult>;
+export declare function formatBatchResult(result: BatchResult): string;
+//# sourceMappingURL=parallel-batch.d.ts.map

package/dist/commands/parallel-batch.js

@@ -0,0 +1,90 @@
+/**
+ * Parallel batch sub-agents — spawn test/lint/build runners per module
+ * in parallel during quality scoring. Collects results and aggregates.
+ */
+export const DEFAULT_BATCH_CONFIG = {
+    maxParallel: 4,
+    timeoutMs: 60_000,
+};
+// ── Job creation ──
+let _jobCounter = 0;
+export function createJob(name, command, module) {
+    _jobCounter++;
+    return {
+        id: `job-${Date.now()}-${_jobCounter}`,
+        name,
+        command,
+        module,
+        status: "pending",
+        startedAt: null,
+        completedAt: null,
+        durationMs: 0,
+        exitCode: null,
+        stdout: "",
+        stderr: "",
+    };
+}
+/**
+ * Default executor — runs command via child_process.
+ */
+export function createShellExecutor(timeoutMs = 60_000) {
+    return async (job) => {
+        const { execFile } = await import("child_process");
+        const { promisify } = await import("util");
+        const execFileAsync = promisify(execFile);
+        job.status = "running";
+        job.startedAt = Date.now();
+        try {
+            const { stdout, stderr } = await execFileAsync("sh", ["-c", job.command], { timeout: timeoutMs, maxBuffer: 5 * 1024 * 1024 });
+            job.stdout = stdout;
+            job.stderr = stderr;
+            job.exitCode = 0;
+            job.status = "done";
+        }
+        catch (err) {
+            const e = err;
+            job.stdout = e.stdout ?? "";
+            job.stderr = e.stderr ?? "";
+            job.exitCode = e.killed ? -1 : (e.code ?? 1);
+            job.status = "error";
+        }
+        job.completedAt = Date.now();
+        job.durationMs = job.completedAt - job.startedAt;
+        return job;
+    };
+}
+/**
+ * Run jobs in parallel with configurable concurrency.
+ */
+export async function runBatch(jobs, executor, config = DEFAULT_BATCH_CONFIG) {
+    const start = Date.now();
+    const results = [];
+    const queue = [...jobs];
+    // Process in waves of maxParallel
+    while (queue.length > 0) {
+        const wave = queue.splice(0, config.maxParallel);
+        const waveResults = await Promise.all(wave.map((j) => executor(j)));
+        results.push(...waveResults);
+    }
+    return {
+        jobs: results,
+        totalDurationMs: Date.now() - start,
+        passedCount: results.filter((j) => j.status === "done").length,
+        failedCount: results.filter((j) => j.status === "error").length,
+        parallelism: config.maxParallel,
+    };
+}
+// ── Formatting ──
+export function formatBatchResult(result) {
+    const status = result.failedCount === 0 ? "✅ ALL PASSED" : "❌ FAILURES";
+    const lines = [];
+    lines.push(`## Batch Result: ${status}`);
+    lines.push(`**Jobs**: ${result.jobs.length} | **Passed**: ${result.passedCount} | **Failed**: ${result.failedCount} | **Time**: ${result.totalDurationMs}ms | **Parallelism**: ${result.parallelism}`);
+    lines.push("");
+    for (const job of result.jobs) {
+        const icon = job.status === "done" ? "✓" : "✗";
+        lines.push(`  ${icon} ${job.name} (${job.module}) — ${job.durationMs}ms [exit ${job.exitCode}]`);
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=parallel-batch.js.map

package/dist/commands/plugin.d.ts

@@ -1,4 +1,4 @@
-import type { InitStep } from '../types/index.js';
+import type { InitStep } from "../types/index.js";
 type StepCallback = (step: InitStep) => void;
 /**
  * Add (install) a plugin from a GitHub source.
@@ -36,5 +36,14 @@ export declare function runPluginExportCodex(name: string, onStep: StepCallback)
  * Import an Agent Skills spec package and convert to javi-forge plugin format.
  */
 export declare function runPluginImport(sourceDir: string, dryRun: boolean, onStep: StepCallback): Promise<void>;
+/**
+ * Generate a project-level skills.json from all installed plugins.
+ * Makes the project discoverable by `npx skills add` and 40+ AI agents.
+ */
+export declare function runPluginExportSkillsJson(projectDir: string, dryRun: boolean, onStep: StepCallback): Promise<void>;
+/**
+ * Generate a global skills.json from all globally installed plugins.
+ */
+export declare function runPluginExportGlobalSkillsJson(dryRun: boolean, onStep: StepCallback): Promise<void>;
 export {};
 //# sourceMappingURL=plugin.d.ts.map

package/dist/commands/plugin.js

@@ -1,6 +1,6 @@
-import { installPlugin, removePlugin, listInstalledPlugins, validatePlugin, searchRegistry, syncPlugins, } from '../lib/plugin.js';
-import { exportPluginAsAgentSkills, importAgentSkillsPackage } from '../lib/agent-skills.js';
-import { exportPluginAsCodexToml } from '../lib/codex-export.js';
+import { exportPluginAsAgentSkills, generateGlobalSkillsJson, generateProjectSkillsJson, importAgentSkillsPackage, } from "../lib/agent-skills.js";
+import { exportPluginAsCodexToml } from "../lib/codex-export.js";
+import { installPlugin, listInstalledPlugins, removePlugin, searchRegistry, syncPlugins, validatePlugin, } from "../lib/plugin.js";
 function report(onStep, id, label, status, detail) {
     onStep({ id, label, status, detail });
 }
@@ -8,140 +8,185 @@ function report(onStep, id, label, status, detail) {
  * Add (install) a plugin from a GitHub source.
  */
 export async function runPluginAdd(source, dryRun, onStep) {
-    const stepId = 'plugin-add';
-    report(onStep, stepId, `Install plugin: ${source}`, 'running');
+    const stepId = "plugin-add";
+    report(onStep, stepId, `Install plugin: ${source}`, "running");
     const result = await installPlugin(source, { dryRun });
     if (result.success) {
-        report(onStep, stepId, `Install plugin: ${source}`, 'done', dryRun ? `dry-run: would install ${result.name}` : `installed ${result.name}`);
+        report(onStep, stepId, `Install plugin: ${source}`, "done", dryRun
+            ? `dry-run: would install ${result.name}`
+            : `installed ${result.name}`);
     }
     else {
-        report(onStep, stepId, `Install plugin: ${source}`, 'error', result.error);
+        report(onStep, stepId, `Install plugin: ${source}`, "error", result.error);
     }
 }
 /**
  * Remove an installed plugin by name.
  */
 export async function runPluginRemove(name, dryRun, onStep) {
-    const stepId = 'plugin-remove';
-    report(onStep, stepId, `Remove plugin: ${name}`, 'running');
+    const stepId = "plugin-remove";
+    report(onStep, stepId, `Remove plugin: ${name}`, "running");
     const result = await removePlugin(name, { dryRun });
     if (result.success) {
-        report(onStep, stepId, `Remove plugin: ${name}`, 'done', dryRun ? `dry-run: would remove ${name}` : `removed ${name}`);
+        report(onStep, stepId, `Remove plugin: ${name}`, "done", dryRun ? `dry-run: would remove ${name}` : `removed ${name}`);
     }
     else {
-        report(onStep, stepId, `Remove plugin: ${name}`, 'error', result.error);
+        report(onStep, stepId, `Remove plugin: ${name}`, "error", result.error);
     }
 }
 /**
  * List all installed plugins.
  */
 export async function runPluginList(onStep) {
-    const stepId = 'plugin-list';
-    report(onStep, stepId, 'List installed plugins', 'running');
+    const stepId = "plugin-list";
+    report(onStep, stepId, "List installed plugins", "running");
     const plugins = await listInstalledPlugins();
     if (plugins.length === 0) {
-        report(onStep, stepId, 'List installed plugins', 'done', 'no plugins installed');
+        report(onStep, stepId, "List installed plugins", "done", "no plugins installed");
     }
     else {
-        const summary = plugins.map(p => `${p.name}@${p.version}`).join(', ');
-        report(onStep, stepId, 'List installed plugins', 'done', `${plugins.length} plugins: ${summary}`);
+        const summary = plugins.map((p) => `${p.name}@${p.version}`).join(", ");
+        report(onStep, stepId, "List installed plugins", "done", `${plugins.length} plugins: ${summary}`);
     }
 }
 /**
  * Search the remote plugin registry.
  */
 export async function runPluginSearch(query, onStep) {
-    const stepId = 'plugin-search';
-    report(onStep, stepId, `Search plugins${query ? `: ${query}` : ''}`, 'running');
+    const stepId = "plugin-search";
+    report(onStep, stepId, `Search plugins${query ? `: ${query}` : ""}`, "running");
     const results = await searchRegistry(query);
     if (results.length === 0) {
-        report(onStep, stepId, `Search plugins${query ? `: ${query}` : ''}`, 'done', query ? `no plugins matching "${query}"` : 'registry empty or unreachable');
+        report(onStep, stepId, `Search plugins${query ? `: ${query}` : ""}`, "done", query
+            ? `no plugins matching "${query}"`
+            : "registry empty or unreachable");
     }
     else {
-        const summary = results.map(p => `${p.id} — ${p.description}`).join('\n  ');
-        report(onStep, stepId, `Search plugins${query ? `: ${query}` : ''}`, 'done', `${results.length} results:\n  ${summary}`);
+        const summary = results
+            .map((p) => `${p.id} — ${p.description}`)
+            .join("\n  ");
+        report(onStep, stepId, `Search plugins${query ? `: ${query}` : ""}`, "done", `${results.length} results:\n  ${summary}`);
     }
 }
 /**
  * Validate a local plugin directory.
  */
 export async function runPluginValidate(pluginDir, onStep) {
-    const stepId = 'plugin-validate';
-    report(onStep, stepId, `Validate plugin: ${pluginDir}`, 'running');
+    const stepId = "plugin-validate";
+    report(onStep, stepId, `Validate plugin: ${pluginDir}`, "running");
     const result = await validatePlugin(pluginDir);
     if (result.valid) {
-        report(onStep, stepId, `Validate plugin: ${pluginDir}`, 'done', `valid — ${result.manifest?.name}@${result.manifest?.version}`);
+        report(onStep, stepId, `Validate plugin: ${pluginDir}`, "done", `valid — ${result.manifest?.name}@${result.manifest?.version}`);
     }
     else {
-        const msgs = result.errors.map(e => `  ${e.path}: ${e.message}`).join('\n');
-        report(onStep, stepId, `Validate plugin: ${pluginDir}`, 'error', `${result.errors.length} errors:\n${msgs}`);
+        const msgs = result.errors
+            .map((e) => `  ${e.path}: ${e.message}`)
+            .join("\n");
+        report(onStep, stepId, `Validate plugin: ${pluginDir}`, "error", `${result.errors.length} errors:\n${msgs}`);
     }
 }
 /**
  * Sync detected plugins into the project manifest.
  */
 export async function runPluginSync(projectDir, dryRun, onStep) {
-    const stepId = 'plugin-sync';
-    report(onStep, stepId, 'Sync plugins', 'running');
+    const stepId = "plugin-sync";
+    report(onStep, stepId, "Sync plugins", "running");
     try {
         const result = await syncPlugins(projectDir, { dryRun });
         const parts = [];
         if (result.added.length > 0)
-            parts.push(`added: ${result.added.join(', ')}`);
+            parts.push(`added: ${result.added.join(", ")}`);
         if (result.removed.length > 0)
-            parts.push(`removed: ${result.removed.join(', ')}`);
+            parts.push(`removed: ${result.removed.join(", ")}`);
         if (result.unchanged.length > 0)
-            parts.push(`unchanged: ${result.unchanged.join(', ')}`);
+            parts.push(`unchanged: ${result.unchanged.join(", ")}`);
+        if (result.wired.length > 0)
+            parts.push(`wired: ${result.wired.length} capabilities`);
+        if (result.unwired.length > 0)
+            parts.push(`unwired: ${result.unwired.length} capabilities`);
         if (parts.length === 0)
-            parts.push('no plugins detected');
-        const prefix = dryRun ? 'dry-run: ' : '';
-        report(onStep, stepId, 'Sync plugins', 'done', `${prefix}${parts.join(' | ')}`);
+            parts.push("no plugins detected");
+        const prefix = dryRun ? "dry-run: " : "";
+        report(onStep, stepId, "Sync plugins", "done", `${prefix}${parts.join(" | ")}`);
     }
     catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
-        report(onStep, stepId, 'Sync plugins', 'error', msg);
+        report(onStep, stepId, "Sync plugins", "error", msg);
     }
 }
 /**
  * Export an installed plugin to Agent Skills spec format.
  */
 export async function runPluginExport(name, onStep) {
-    const stepId = 'plugin-export';
-    report(onStep, stepId, `Export plugin: ${name}`, 'running');
+    const stepId = "plugin-export";
+    report(onStep, stepId, `Export plugin: ${name}`, "running");
     const result = await exportPluginAsAgentSkills(name);
     if (result.success) {
-        report(onStep, stepId, `Export plugin: ${name}`, 'done', `exported to ${result.path}`);
+        report(onStep, stepId, `Export plugin: ${name}`, "done", `exported to ${result.path}`);
     }
     else {
-        report(onStep, stepId, `Export plugin: ${name}`, 'error', result.error);
+        report(onStep, stepId, `Export plugin: ${name}`, "error", result.error);
     }
 }
 /**
  * Export an installed plugin to Codex-compatible TOML subagent files.
  */
 export async function runPluginExportCodex(name, onStep) {
-    const stepId = 'plugin-export-codex';
-    report(onStep, stepId, `Export plugin as Codex TOML: ${name}`, 'running');
+    const stepId = "plugin-export-codex";
+    report(onStep, stepId, `Export plugin as Codex TOML: ${name}`, "running");
     const result = await exportPluginAsCodexToml(name);
     if (result.success) {
-        report(onStep, stepId, `Export plugin as Codex TOML: ${name}`, 'done', `exported ${result.files.length} TOML file(s)`);
+        report(onStep, stepId, `Export plugin as Codex TOML: ${name}`, "done", `exported ${result.files.length} TOML file(s)`);
     }
     else {
-        report(onStep, stepId, `Export plugin as Codex TOML: ${name}`, 'error', result.error);
+        report(onStep, stepId, `Export plugin as Codex TOML: ${name}`, "error", result.error);
     }
 }
 /**
  * Import an Agent Skills spec package and convert to javi-forge plugin format.
  */
 export async function runPluginImport(sourceDir, dryRun, onStep) {
-    const stepId = 'plugin-import';
-    report(onStep, stepId, `Import agent-skills package: ${sourceDir}`, 'running');
+    const stepId = "plugin-import";
+    report(onStep, stepId, `Import agent-skills package: ${sourceDir}`, "running");
     const result = await importAgentSkillsPackage(sourceDir, { dryRun });
     if (result.success) {
-        report(onStep, stepId, `Import agent-skills package: ${sourceDir}`, 'done', dryRun ? `dry-run: would import ${result.name}` : `imported ${result.name}`);
+        report(onStep, stepId, `Import agent-skills package: ${sourceDir}`, "done", dryRun
+            ? `dry-run: would import ${result.name}`
+            : `imported ${result.name}`);
     }
     else {
-        report(onStep, stepId, `Import agent-skills package: ${sourceDir}`, 'error', result.error);
+        report(onStep, stepId, `Import agent-skills package: ${sourceDir}`, "error", result.error);
+    }
+}
+/**
+ * Generate a project-level skills.json from all installed plugins.
+ * Makes the project discoverable by `npx skills add` and 40+ AI agents.
+ */
+export async function runPluginExportSkillsJson(projectDir, dryRun, onStep) {
+    const stepId = "plugin-export-skills-json";
+    report(onStep, stepId, "Generate project skills.json", "running");
+    const result = await generateProjectSkillsJson(projectDir, { dryRun });
+    if (result.success) {
+        const prefix = dryRun ? "dry-run: would generate" : "generated";
+        report(onStep, stepId, "Generate project skills.json", "done", `${prefix} ${result.path} (${result.skillCount} skills from ${result.pluginCount} plugins)`);
+    }
+    else {
+        report(onStep, stepId, "Generate project skills.json", "error", result.error);
+    }
+}
+/**
+ * Generate a global skills.json from all globally installed plugins.
+ */
+export async function runPluginExportGlobalSkillsJson(dryRun, onStep) {
+    const stepId = "plugin-export-global-skills-json";
+    report(onStep, stepId, "Generate global skills.json", "running");
+    const result = await generateGlobalSkillsJson({ dryRun });
+    if (result.success) {
+        const prefix = dryRun ? "dry-run: would generate" : "generated";
+        report(onStep, stepId, "Generate global skills.json", "done", `${prefix} ${result.path} (${result.skillCount} skills from ${result.pluginCount} plugins)`);
+    }
+    else {
+        report(onStep, stepId, "Generate global skills.json", "error", result.error);
     }
 }
 //# sourceMappingURL=plugin.js.map

package/dist/commands/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