@claude-flow/cli 3.32.2 → 3.32.3

package/dist/src/services/workspace-lease.d.ts

@@ -1,55 +0,0 @@
-/**
- * #2661 root-fix — worktree leases.
- *
- * Registers which worktrees of a repository are currently "alive" (have a
- * running daemon actively heartbeating), independent of whether that
- * worktree's daemon is the elected repository supervisor (see
- * repo-supervisor.ts). A lease expires after 15 minutes without a heartbeat
- * — a removed worktree, or a daemon that crashed without a graceful
- * shutdown, becomes ineligible within one expiry window instead of lingering
- * forever in the registry.
- *
- * The registry lives under the user's home directory (not the workspace) so
- * it is visible to every worktree's daemon, keyed by repositoryId:
- *
- *   ~/.claude-flow/leases/<repositoryId>.json
- *
- * This is deliberately a thin, single-purpose registry — repo-supervisor.ts
- * is the piece that actually elects one process to own the recurring AI
- * worker schedule; leases only answer "which worktrees are currently live"
- * for status reporting and future supervisor-dispatched work.
- */
-export declare const LEASE_TTL_MS: number;
-export interface LeaseRecord {
-    worktreeRoot: string;
-    pid: number;
-    registeredAt: number;
-    lastHeartbeat: number;
-}
-export declare class WorkspaceLeaseRegistry {
-    private readonly dir;
-    constructor(options?: {
-        baseDir?: string;
-    });
-    private fileFor;
-    private ensureDir;
-    private withLock;
-    private readFile;
-    private writeFile;
-    /** Register or renew this process's lease on a worktree. Best-effort. */
-    heartbeat(repositoryId: string, worktreeRoot: string): Promise<void>;
-    /** Release this worktree's lease on graceful shutdown. Best-effort. */
-    release(repositoryId: string, worktreeRoot: string): Promise<void>;
-    /**
-     * Active leases for a repository — expired (>15 min stale) or dead-PID
-     * entries are excluded, not just filtered at read time, so callers never
-     * see a worktree that's actually gone.
-     */
-    listActive(repositoryId: string): LeaseRecord[];
-    /** True when the given worktree currently holds a live (non-expired) lease. */
-    isLeaseActive(repositoryId: string, worktreeRoot: string): boolean;
-}
-export declare function getWorkspaceLeaseRegistry(): WorkspaceLeaseRegistry;
-/** Test hook: reset the singleton (e.g. after changing RUFLO_AI_BUDGET_DIR). */
-export declare function resetWorkspaceLeaseRegistryForTests(): void;
-//# sourceMappingURL=workspace-lease.d.ts.map

package/dist/src/services/workspace-lease.js

@@ -1,191 +0,0 @@
-/**
- * #2661 root-fix — worktree leases.
- *
- * Registers which worktrees of a repository are currently "alive" (have a
- * running daemon actively heartbeating), independent of whether that
- * worktree's daemon is the elected repository supervisor (see
- * repo-supervisor.ts). A lease expires after 15 minutes without a heartbeat
- * — a removed worktree, or a daemon that crashed without a graceful
- * shutdown, becomes ineligible within one expiry window instead of lingering
- * forever in the registry.
- *
- * The registry lives under the user's home directory (not the workspace) so
- * it is visible to every worktree's daemon, keyed by repositoryId:
- *
- *   ~/.claude-flow/leases/<repositoryId>.json
- *
- * This is deliberately a thin, single-purpose registry — repo-supervisor.ts
- * is the piece that actually elects one process to own the recurring AI
- * worker schedule; leases only answer "which worktrees are currently live"
- * for status reporting and future supervisor-dispatched work.
- */
-import * as fs from 'fs';
-import { join } from 'path';
-import { homedir } from 'os';
-import { createHash } from 'crypto';
-export const LEASE_TTL_MS = 15 * 60 * 1000; // 15 minutes — issue #2661 spec
-const LOCK_STALE_MS = 10_000;
-function delay(ms) {
-    return new Promise((r) => setTimeout(r, ms));
-}
-function isProcessAlive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/** Invariant 9 (#2661): registry files must never be symlinks. */
-function assertNotSymlink(path) {
-    try {
-        const st = fs.lstatSync(path);
-        if (st.isSymbolicLink()) {
-            throw new Error(`Workspace lease file is a symlink (refusing): ${path}`);
-        }
-    }
-    catch (e) {
-        if (e.code === 'ENOENT')
-            return;
-        throw e;
-    }
-}
-function leaseKey(worktreeRoot) {
-    return createHash('sha256').update(worktreeRoot).digest('hex').slice(0, 16);
-}
-export class WorkspaceLeaseRegistry {
-    dir;
-    constructor(options) {
-        this.dir = options?.baseDir
-            ?? process.env.RUFLO_AI_BUDGET_DIR // shares the same override as global-ai-budget for test isolation
-            ?? join(homedir(), '.claude-flow');
-    }
-    fileFor(repositoryId) {
-        return join(this.dir, 'leases', `${repositoryId}.json`);
-    }
-    ensureDir(repositoryId) {
-        const dir = join(this.dir, 'leases');
-        if (!fs.existsSync(dir))
-            fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
-        void repositoryId;
-    }
-    async withLock(repositoryId, fn) {
-        this.ensureDir(repositoryId);
-        const lockFile = `${this.fileFor(repositoryId)}.lock`;
-        const deadline = Date.now() + 2000;
-        for (;;) {
-            try {
-                const fd = fs.openSync(lockFile, fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_WRONLY, 0o600);
-                fs.writeSync(fd, String(process.pid));
-                fs.closeSync(fd);
-                try {
-                    return fn();
-                }
-                finally {
-                    try {
-                        fs.unlinkSync(lockFile);
-                    }
-                    catch { /* already gone */ }
-                }
-            }
-            catch (e) {
-                if (e.code !== 'EEXIST')
-                    throw e;
-                try {
-                    const st = fs.lstatSync(lockFile);
-                    if (Date.now() - st.mtimeMs > LOCK_STALE_MS) {
-                        fs.unlinkSync(lockFile);
-                        continue;
-                    }
-                }
-                catch { /* raced — retry */ }
-                if (Date.now() > deadline)
-                    throw new Error('timed out acquiring workspace-lease lock');
-                await delay(25);
-            }
-        }
-    }
-    readFile(repositoryId) {
-        const file = this.fileFor(repositoryId);
-        assertNotSymlink(file);
-        let parsed = { version: 1, leases: {} };
-        if (fs.existsSync(file)) {
-            try {
-                const raw = JSON.parse(fs.readFileSync(file, 'utf-8'));
-                if (raw && typeof raw === 'object' && raw.leases && typeof raw.leases === 'object') {
-                    parsed = { version: 1, leases: raw.leases };
-                }
-            }
-            catch { /* corrupt — start fresh */ }
-        }
-        return parsed;
-    }
-    writeFile(repositoryId, data) {
-        const file = this.fileFor(repositoryId);
-        assertNotSymlink(file);
-        const tmp = `${file}.tmp.${process.pid}`;
-        fs.writeFileSync(tmp, JSON.stringify(data), { mode: 0o600 });
-        fs.renameSync(tmp, file);
-    }
-    /** Register or renew this process's lease on a worktree. Best-effort. */
-    async heartbeat(repositoryId, worktreeRoot) {
-        try {
-            await this.withLock(repositoryId, () => {
-                const data = this.readFile(repositoryId);
-                const now = Date.now();
-                const key = leaseKey(worktreeRoot);
-                const existing = data.leases[key];
-                data.leases[key] = {
-                    worktreeRoot,
-                    pid: process.pid,
-                    registeredAt: existing?.registeredAt ?? now,
-                    lastHeartbeat: now,
-                };
-                this.writeFile(repositoryId, data);
-            });
-        }
-        catch { /* best-effort — a missed heartbeat just expires the lease early */ }
-    }
-    /** Release this worktree's lease on graceful shutdown. Best-effort. */
-    async release(repositoryId, worktreeRoot) {
-        try {
-            await this.withLock(repositoryId, () => {
-                const data = this.readFile(repositoryId);
-                delete data.leases[leaseKey(worktreeRoot)];
-                this.writeFile(repositoryId, data);
-            });
-        }
-        catch { /* best-effort */ }
-    }
-    /**
-     * Active leases for a repository — expired (>15 min stale) or dead-PID
-     * entries are excluded, not just filtered at read time, so callers never
-     * see a worktree that's actually gone.
-     */
-    listActive(repositoryId) {
-        try {
-            const data = this.readFile(repositoryId);
-            const now = Date.now();
-            return Object.values(data.leases).filter((l) => now - l.lastHeartbeat < LEASE_TTL_MS && isProcessAlive(l.pid));
-        }
-        catch {
-            return [];
-        }
-    }
-    /** True when the given worktree currently holds a live (non-expired) lease. */
-    isLeaseActive(repositoryId, worktreeRoot) {
-        return this.listActive(repositoryId).some((l) => l.worktreeRoot === worktreeRoot);
-    }
-}
-let registryInstance = null;
-export function getWorkspaceLeaseRegistry() {
-    if (!registryInstance)
-        registryInstance = new WorkspaceLeaseRegistry();
-    return registryInstance;
-}
-/** Test hook: reset the singleton (e.g. after changing RUFLO_AI_BUDGET_DIR). */
-export function resetWorkspaceLeaseRegistryForTests() {
-    registryInstance = null;
-}
-//# sourceMappingURL=workspace-lease.js.map

package/dist/src/suggest.d.ts

@@ -1,53 +0,0 @@
-/**
- * V3 CLI Smart Error Suggestions
- * Levenshtein distance and command suggestions
- *
- * Created with ruv.io
- */
-/**
- * Calculate Levenshtein distance between two strings
- */
-export declare function levenshteinDistance(a: string, b: string): number;
-/**
- * Calculate similarity score (0-1) between two strings
- */
-export declare function similarityScore(a: string, b: string): number;
-/**
- * Find similar strings from a list
- */
-export declare function findSimilar(input: string, candidates: string[], options?: {
-    maxSuggestions?: number;
-    minSimilarity?: number;
-    maxDistance?: number;
-}): string[];
-/**
- * Format suggestion message for CLI errors
- */
-export declare function formatSuggestion(invalidInput: string, suggestions: string[], context?: 'command' | 'subcommand' | 'option' | 'value'): string;
-/**
- * Common typos and their corrections
- */
-export declare const COMMON_TYPOS: Record<string, string>;
-/**
- * Get corrected command if it's a common typo
- */
-export declare function getTypoCorrection(input: string): string | undefined;
-/**
- * Smart command suggestion for unknown commands
- */
-export declare function suggestCommand(unknownCommand: string, availableCommands: string[]): {
-    correction?: string;
-    suggestions: string[];
-    message: string;
-};
-declare const _default: {
-    levenshteinDistance: typeof levenshteinDistance;
-    similarityScore: typeof similarityScore;
-    findSimilar: typeof findSimilar;
-    formatSuggestion: typeof formatSuggestion;
-    suggestCommand: typeof suggestCommand;
-    getTypoCorrection: typeof getTypoCorrection;
-    COMMON_TYPOS: Record<string, string>;
-};
-export default _default;
-//# sourceMappingURL=suggest.d.ts.map

package/dist/src/suggest.js

@@ -1,200 +0,0 @@
-/**
- * V3 CLI Smart Error Suggestions
- * Levenshtein distance and command suggestions
- *
- * Created with ruv.io
- */
-/**
- * Calculate Levenshtein distance between two strings
- */
-export function levenshteinDistance(a, b) {
-    const m = a.length;
-    const n = b.length;
-    // Early termination for empty strings
-    if (m === 0)
-        return n;
-    if (n === 0)
-        return m;
-    // Create distance matrix
-    const d = Array(m + 1).fill(null).map(() => Array(n + 1).fill(0));
-    // Initialize first column
-    for (let i = 0; i <= m; i++) {
-        d[i][0] = i;
-    }
-    // Initialize first row
-    for (let j = 0; j <= n; j++) {
-        d[0][j] = j;
-    }
-    // Fill in the rest of the matrix
-    for (let j = 1; j <= n; j++) {
-        for (let i = 1; i <= m; i++) {
-            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-            d[i][j] = Math.min(d[i - 1][j] + 1, // deletion
-            d[i][j - 1] + 1, // insertion
-            d[i - 1][j - 1] + cost // substitution
-            );
-        }
-    }
-    return d[m][n];
-}
-/**
- * Calculate similarity score (0-1) between two strings
- */
-export function similarityScore(a, b) {
-    const maxLen = Math.max(a.length, b.length);
-    if (maxLen === 0)
-        return 1;
-    const distance = levenshteinDistance(a.toLowerCase(), b.toLowerCase());
-    return 1 - distance / maxLen;
-}
-/**
- * Find similar strings from a list
- */
-export function findSimilar(input, candidates, options = {}) {
-    const { maxSuggestions = 3, minSimilarity = 0.4, maxDistance = 3 } = options;
-    const inputLower = input.toLowerCase();
-    // Score all candidates
-    const scored = candidates
-        .map(candidate => ({
-        candidate,
-        distance: levenshteinDistance(inputLower, candidate.toLowerCase()),
-        similarity: similarityScore(inputLower, candidate),
-        // Boost prefix matches
-        prefixBoost: candidate.toLowerCase().startsWith(inputLower) ? 0.3 : 0
-    }))
-        .filter(s => s.distance <= maxDistance || s.similarity >= minSimilarity)
-        .map(s => ({
-        ...s,
-        score: s.similarity + s.prefixBoost
-    }))
-        .sort((a, b) => b.score - a.score)
-        .slice(0, maxSuggestions);
-    return scored.map(s => s.candidate);
-}
-/**
- * Format suggestion message for CLI errors
- */
-export function formatSuggestion(invalidInput, suggestions, context = 'command') {
-    if (suggestions.length === 0) {
-        return '';
-    }
-    const contextMap = {
-        command: 'Did you mean',
-        subcommand: 'Available subcommands',
-        option: 'Did you mean',
-        value: 'Valid values'
-    };
-    const prefix = contextMap[context];
-    if (suggestions.length === 1) {
-        return `\n  ${prefix}: ${suggestions[0]}`;
-    }
-    return `\n  ${prefix}:\n${suggestions.map(s => `    - ${s}`).join('\n')}`;
-}
-/**
- * Common typos and their corrections
- */
-export const COMMON_TYPOS = {
-    'init': 'init',
-    'initi': 'init',
-    'inizialize': 'init',
-    'staus': 'status',
-    'stauts': 'status',
-    'stats': 'stats',
-    'stat': 'status',
-    'swarrm': 'swarm',
-    'swarn': 'swarm',
-    'agnet': 'agent',
-    'agen': 'agent',
-    'memroy': 'memory',
-    'mem': 'memory',
-    'memmory': 'memory',
-    'confg': 'config',
-    'conf': 'config',
-    'configu': 'config',
-    'hook': 'hooks',
-    'hoks': 'hooks',
-    'hive': 'hive-mind',
-    'hivemind': 'hive-mind',
-    'hive_mind': 'hive-mind',
-    'neurl': 'neural',
-    'nueral': 'neural',
-    'securty': 'security',
-    'sec': 'security',
-    'perf': 'performance',
-    'performace': 'performance',
-    'provider': 'providers',
-    'plugin': 'plugins',
-    'dep': 'deployment',
-    'depoly': 'deployment',
-    'deploy': 'deployment',
-    'claim': 'claims',
-    'embed': 'embeddings',
-    'embeding': 'embeddings',
-    'daemon': 'daemon',
-    'deamon': 'daemon',
-    'doc': 'doctor',
-    'docter': 'doctor',
-    'complete': 'completions',
-    'completion': 'completions',
-    'comp': 'completions',
-    'task': 'task',
-    'taks': 'task',
-    'sessio': 'session',
-    'sess': 'session',
-    'sesssion': 'session',
-    'workflow': 'workflow',
-    'wf': 'workflow',
-    'wokflow': 'workflow'
-};
-/**
- * Get corrected command if it's a common typo
- */
-export function getTypoCorrection(input) {
-    return COMMON_TYPOS[input.toLowerCase()];
-}
-/**
- * Smart command suggestion for unknown commands
- */
-export function suggestCommand(unknownCommand, availableCommands) {
-    // Check for common typo first
-    const correction = getTypoCorrection(unknownCommand);
-    if (correction && availableCommands.includes(correction)) {
-        return {
-            correction,
-            suggestions: [correction],
-            message: `Did you mean "${correction}"?`
-        };
-    }
-    // Find similar commands
-    const suggestions = findSimilar(unknownCommand, availableCommands, {
-        maxSuggestions: 3,
-        minSimilarity: 0.3,
-        maxDistance: 4
-    });
-    if (suggestions.length === 0) {
-        return {
-            suggestions: [],
-            message: 'Run "claude-flow --help" to see available commands.'
-        };
-    }
-    if (suggestions.length === 1) {
-        return {
-            suggestions,
-            message: `Did you mean "${suggestions[0]}"?`
-        };
-    }
-    return {
-        suggestions,
-        message: `Did you mean one of these?\n${suggestions.map(s => `  - ${s}`).join('\n')}`
-    };
-}
-export default {
-    levenshteinDistance,
-    similarityScore,
-    findSimilar,
-    formatSuggestion,
-    suggestCommand,
-    getTypoCorrection,
-    COMMON_TYPOS
-};
-//# sourceMappingURL=suggest.js.map

package/dist/src/transfer/anonymization/index.d.ts

@@ -1,25 +0,0 @@
-/**
- * Anonymization Pipeline
- * PII detection and redaction for pattern export
- */
-import type { CFPFormat, AnonymizationLevel, PIIDetectionResult } from '../types.js';
-/**
- * Detect PII in a string
- */
-export declare function detectPII(content: string): PIIDetectionResult;
-/**
- * Redact PII from a string
- */
-export declare function redactPII(content: string): string;
-/**
- * Apply anonymization to CFP document
- */
-export declare function anonymizeCFP(cfp: CFPFormat, level: AnonymizationLevel): {
-    cfp: CFPFormat;
-    transforms: string[];
-};
-/**
- * Scan CFP for PII without modification
- */
-export declare function scanCFPForPII(cfp: CFPFormat): PIIDetectionResult;
-//# sourceMappingURL=index.d.ts.map

package/dist/src/transfer/anonymization/index.js

@@ -1,175 +0,0 @@
-/**
- * Anonymization Pipeline
- * PII detection and redaction for pattern export
- */
-import * as crypto from 'crypto';
-/**
- * PII detection patterns
- */
-const PII_PATTERNS = {
-    email: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g,
-    phone: /\b(\+?\d{1,3}[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b/g,
-    ipv4: /\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b/g,
-    ipv6: /\b(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}\b/g,
-    apiKey: /\b(sk-|pk-|api[_-]?key[_-]?)[a-zA-Z0-9]{20,}\b/gi,
-    jwt: /\beyJ[a-zA-Z0-9_-]*\.eyJ[a-zA-Z0-9_-]*\.[a-zA-Z0-9_-]*\b/g,
-    homePath: /\/(Users|home|Documents)\/[a-zA-Z0-9_.-]+/g,
-    windowsPath: /[A-Z]:\\Users\\[a-zA-Z0-9_.-]+/g,
-};
-/**
- * Redaction replacements
- */
-const REDACTIONS = {
-    email: (match) => `user_${hash(match).slice(0, 8)}@example.com`,
-    phone: '[REDACTED_PHONE]',
-    ipv4: '0.0.0.0',
-    ipv6: '::1',
-    apiKey: '[REDACTED_API_KEY]',
-    jwt: '[REDACTED_JWT]',
-    homePath: '/user/anonymous',
-    windowsPath: 'C:\\Users\\anonymous',
-};
-/**
- * Hash a string for consistent pseudonymization
- */
-function hash(input) {
-    return crypto.createHash('sha256').update(input).digest('hex');
-}
-/**
- * Detect PII in a string
- */
-export function detectPII(content) {
-    const result = {
-        found: false,
-        count: 0,
-        types: {},
-        locations: [],
-    };
-    for (const [type, pattern] of Object.entries(PII_PATTERNS)) {
-        const matches = content.match(pattern);
-        if (matches) {
-            result.found = true;
-            result.count += matches.length;
-            result.types[type] = matches.length;
-            for (const match of matches.slice(0, 5)) { // Limit to first 5 samples
-                result.locations.push({
-                    type,
-                    path: 'content',
-                    sample: match.slice(0, 20) + (match.length > 20 ? '...' : ''),
-                    severity: getSeverity(type),
-                });
-            }
-        }
-    }
-    return result;
-}
-/**
- * Get severity for PII type
- */
-function getSeverity(type) {
-    switch (type) {
-        case 'apiKey':
-        case 'jwt':
-            return 'critical';
-        case 'email':
-        case 'phone':
-            return 'high';
-        case 'ipv4':
-        case 'ipv6':
-            return 'medium';
-        default:
-            return 'low';
-    }
-}
-/**
- * Redact PII from a string
- */
-export function redactPII(content) {
-    let result = content;
-    for (const [type, pattern] of Object.entries(PII_PATTERNS)) {
-        const replacement = REDACTIONS[type];
-        if (typeof replacement === 'function') {
-            result = result.replace(pattern, replacement);
-        }
-        else {
-            result = result.replace(pattern, replacement);
-        }
-    }
-    return result;
-}
-/**
- * Apply anonymization to CFP document
- */
-export function anonymizeCFP(cfp, level) {
-    const transforms = [];
-    const anonymized = JSON.parse(JSON.stringify(cfp));
-    // Level: Minimal
-    if (['minimal', 'standard', 'strict', 'paranoid'].includes(level)) {
-        // Redact author display name
-        if (anonymized.metadata.author?.displayName) {
-            anonymized.metadata.author.displayName = undefined;
-            transforms.push('author-name-removed');
-        }
-    }
-    // Level: Standard
-    if (['standard', 'strict', 'paranoid'].includes(level)) {
-        // Redact PII from all string fields
-        const jsonStr = JSON.stringify(anonymized.patterns);
-        const redacted = redactPII(jsonStr);
-        anonymized.patterns = JSON.parse(redacted);
-        transforms.push('pii-redacted');
-        // Generalize timestamps
-        anonymized.anonymization.timestampsGeneralized = true;
-        transforms.push('timestamps-generalized');
-    }
-    // Level: Strict
-    if (['strict', 'paranoid'].includes(level)) {
-        // Hash all IDs
-        for (const pattern of anonymized.patterns.routing) {
-            pattern.id = `pattern_${hash(pattern.id).slice(0, 12)}`;
-        }
-        transforms.push('ids-hashed');
-        // Remove context details
-        for (const pattern of anonymized.patterns.routing) {
-            pattern.context = undefined;
-        }
-        transforms.push('context-removed');
-        anonymized.anonymization.pathsStripped = true;
-        transforms.push('paths-stripped');
-    }
-    // Level: Paranoid
-    if (level === 'paranoid') {
-        // Add noise to numeric values (differential privacy)
-        for (const pattern of anonymized.patterns.routing) {
-            pattern.usageCount = Math.round(pattern.usageCount * (0.9 + Math.random() * 0.2));
-            pattern.successRate = Math.min(1, Math.max(0, pattern.successRate + (Math.random() - 0.5) * 0.1));
-        }
-        transforms.push('differential-privacy-noise');
-        // Remove all trajectory learnings
-        for (const traj of anonymized.patterns.trajectory) {
-            traj.learnings = [];
-        }
-        transforms.push('learnings-removed');
-    }
-    // Update anonymization record
-    anonymized.anonymization.level = level;
-    anonymized.anonymization.appliedTransforms = transforms;
-    anonymized.anonymization.piiRedacted = level !== 'minimal';
-    // Recalculate checksum
-    const content = JSON.stringify({
-        magic: anonymized.magic,
-        version: anonymized.version,
-        metadata: anonymized.metadata,
-        patterns: anonymized.patterns,
-    });
-    anonymized.anonymization.checksum = hash(content);
-    return { cfp: anonymized, transforms };
-}
-/**
- * Scan CFP for PII without modification
- */
-export function scanCFPForPII(cfp) {
-    const content = JSON.stringify(cfp.patterns);
-    return detectPII(content);
-}
-//# sourceMappingURL=index.js.map