preflight-mcp 0.4.3 → 0.5.0

package/README.md

@@ -51,7 +51,8 @@ Preflight: 🔗 Trace links:
 - 📖 **Auto-generated guides** — `START_HERE.md`, `AGENTS.md`, `OVERVIEW.md`
 - ☁️ **Cloud sync** — Multi-path mirror backup for redundancy
 - 🧠 **EDDA (Evidence-Driven Deep Analysis)** — Auto-generate auditable claims with evidence
-- ⚡ **18 MCP tools + 5 prompts** — Complete toolkit for code exploration
+- ⚡ **22 MCP tools + 5 prompts** — Complete toolkit for code exploration
+- 📄 **Cursor pagination** — Handle large result sets efficiently (RFC v2)
 
 <details>
 <summary><b>All Features (click to expand)</b></summary>
@@ -75,7 +76,7 @@ Preflight: 🔗 Trace links:
 - [Demo](#demo)
 - [Core Features](#core-features)
 - [Quick Start](#quick-start)
-- [Tools](#tools-15-total)
+- [Tools](#tools-22-total)
 - [Prompts](#prompts-5-total)
 - [Environment Variables](#environment-variables)
 - [Contributing](#contributing)
@@ -160,10 +161,11 @@ Run end-to-end smoke test:
 npm run smoke
 ```
 
-## Tools (18 total)
+## Tools (22 total)
 
 ### `preflight_list_bundles`
 List bundle IDs in storage.
+- **Cursor pagination** (v0.5.0): Use `cursor` parameter for large bundle lists
 - Triggers: "show bundles", "查看bundle", "有哪些bundle"
 
 ### `preflight_create_bundle`
@@ -236,10 +238,15 @@ Important: **this tool is strictly read-only**.
 - `fileTypeFilters`: Filter by extension (e.g., `[".py", ".ts"]`)
 - `includeScore`: Include BM25 relevance score in results
 
+**Cursor pagination** (v0.5.0):
+- `cursor`: Pagination cursor from previous call for fetching next page
+- Response includes `truncation.nextCursor` when more results available
+
 **Deprecated parameters**: `ensureFresh`, `autoRepairIndex`, `maxAgeHours` are deprecated and will return warnings instead of errors.
 
 ### `preflight_search_by_tags`
 Search across multiple bundles filtered by tags (line-based SQLite FTS5).
+- **Cursor pagination** (v0.5.0): Use `cursor` parameter for large result sets
 - Triggers: "search in MCP bundles", "在MCP项目中搜索", "搜索所有agent"
 
 Notes:
@@ -250,6 +257,7 @@ Optional parameters:
 - `tags`: Filter bundles by tags (e.g., `["mcp", "agents"]`)
 - `scope`: Search scope (`docs`, `code`, or `all`)
 - `limit`: Max total hits across all bundles
+- `cursor`: Pagination cursor for fetching next page
 
 ### `preflight_evidence_dependency_graph`
 Generate an evidence-based dependency graph. Two modes:
@@ -280,6 +288,7 @@ Create or update traceability links (code↔test, code↔doc, file↔requirement
 ### `preflight_trace_query`
 Query traceability links (code↔test, code↔doc, commit↔ticket).
 - **Proactive use**: LLM automatically queries trace links when analyzing specific files
+- **Cursor pagination** (v0.5.0): Use `cursor` parameter for large result sets
 - Returns `reason` and `nextSteps` when no edges found (helps LLM decide next action)
 - Fast when `bundleId` is provided; can scan across bundles when omitted.
 
@@ -327,6 +336,37 @@ Parameters:
 - `verifyFileExists`: Check evidence files exist (default: true)
 - `strictMode`: Treat warnings as errors (default: false)
 
+### `preflight_read_files` *(NEW v0.5.0)*
+Batch read multiple files from a bundle in a single call.
+- Reduces round-trips for evidence gathering
+- **RFC v2 unified envelope**: Returns `ok`, `meta`, `data`, `evidence[]`
+- Triggers: "read these files", "get content of", "批量读取"
+
+Parameters:
+- `bundleId`: Bundle ID
+- `files[]`: Array of `{path, ranges?, withLineNumbers?}`
+- `format`: `"json"` (default) or `"text"`
+
+### `preflight_search_and_read` *(NEW v0.5.0)*
+Search + excerpt in one call - finds relevant code and returns context.
+- Combines search with automatic context extraction
+- **RFC v2 unified envelope**: Returns `ok`, `meta`, `data`, `evidence[]`
+- Triggers: "search and show code", "find and read", "搜索并读取"
+
+Parameters:
+- `bundleId`: Bundle ID
+- `query`: Search query
+- `contextLines`: Lines of context around matches (default: 5)
+- `maxFiles`: Max files to read (default: 5)
+- `format`: `"json"` (default) or `"text"`
+
+### `preflight_get_dependency_graph` *(Simplified wrapper)*
+Simplified dependency graph query.
+- `scope: "global"` (default): Project-wide graph
+- `scope: "target"` with `targetFile`: Single file dependencies
+- `format: "summary"` (default): Aggregated view
+- `format: "full"`: Raw graph data
+
 ### `preflight_cleanup_orphans`
 Remove incomplete or corrupted bundles (bundles without valid manifest.json).
 - Triggers: "clean up broken bundles", "remove orphans", "清理孤儿bundle"
@@ -393,6 +433,11 @@ Common kinds:
 - `invalid_path` (unsafe path traversal attempt)
 - `permission_denied`
 - `index_missing_or_corrupt`
+- `cursor_invalid` *(v0.5.0)*
+- `cursor_expired` *(v0.5.0)*
+- `rate_limited` *(v0.5.0)*
+- `timeout` *(v0.5.0)*
+- `pagination_required` *(v0.5.0)*
 - `unknown`
 
 This is designed so UIs/agents can reliably decide whether to:

package/dist/evidence/dependencyGraph.js

@@ -66,6 +66,119 @@ function clampSnippet(s, maxLen) {
 function normalizeExt(p) {
     return path.extname(p).toLowerCase();
 }
+/**
+ * Generate a Mermaid flowchart from dependency graph edges.
+ * Limited to top N nodes to keep output readable.
+ */
+function generateMermaidDiagram(edges, maxNodes = 20) {
+    // Count imports per file (both as importer and imported)
+    const importerCounts = new Map();
+    const importedCounts = new Map();
+    for (const e of edges) {
+        if (e.type === 'imports' && e.from && e.to) {
+            importerCounts.set(e.from, (importerCounts.get(e.from) ?? 0) + 1);
+            importedCounts.set(e.to, (importedCounts.get(e.to) ?? 0) + 1);
+        }
+    }
+    // Get top nodes by total connections
+    const allNodes = new Set([...importerCounts.keys(), ...importedCounts.keys()]);
+    const nodeScores = Array.from(allNodes).map(n => ({
+        node: n,
+        score: (importerCounts.get(n) ?? 0) + (importedCounts.get(n) ?? 0),
+    })).sort((a, b) => b.score - a.score).slice(0, maxNodes);
+    const topNodes = new Set(nodeScores.map(n => n.node));
+    // Filter edges to only include top nodes
+    const filteredEdges = edges.filter(e => e.type === 'imports' && e.from && e.to &&
+        topNodes.has(e.from) && topNodes.has(e.to));
+    if (filteredEdges.length === 0) {
+        return '```mermaid\nflowchart LR\n  A[No edges to display]\n```';
+    }
+    // Generate Mermaid syntax
+    const lines = ['```mermaid', 'flowchart LR'];
+    // Create node IDs (sanitize file names)
+    const nodeIds = new Map();
+    let idCounter = 0;
+    const getNodeId = (name) => {
+        if (!nodeIds.has(name)) {
+            nodeIds.set(name, `N${idCounter++}`);
+        }
+        return nodeIds.get(name);
+    };
+    // Add edges
+    const addedEdges = new Set();
+    for (const e of filteredEdges) {
+        const fromId = getNodeId(e.from);
+        const toId = getNodeId(e.to);
+        const edgeKey = `${fromId}->${toId}`;
+        if (!addedEdges.has(edgeKey)) {
+            addedEdges.add(edgeKey);
+            lines.push(`  ${fromId} --> ${toId}`);
+        }
+    }
+    // Add node labels
+    for (const [name, id] of nodeIds) {
+        // Extract just the filename for readability
+        const shortName = name.split('/').pop() ?? name;
+        const safeName = shortName.replace(/["]/g, "'").slice(0, 30);
+        lines.push(`  ${id}["${safeName}"]`);
+    }
+    lines.push('```');
+    return lines.join('\n');
+}
+/**
+ * Identify high-value modules from dependency graph.
+ */
+function identifyHighValueModules(edges, nodes) {
+    const modules = [];
+    // Count imports (as importer and as imported)
+    const importerCounts = new Map();
+    const importedCounts = new Map();
+    for (const e of edges) {
+        if (e.type === 'imports' && e.from && e.to) {
+            importerCounts.set(e.from, (importerCounts.get(e.from) ?? 0) + 1);
+            importedCounts.set(e.to, (importedCounts.get(e.to) ?? 0) + 1);
+        }
+    }
+    // High coupling: files imported by many others (>10)
+    for (const [file, count] of importedCounts) {
+        if (count >= 10) {
+            modules.push({
+                file,
+                reason: 'high_coupling',
+                metric: count,
+                description: `Imported by ${count} files - core module, changes affect many dependents`,
+            });
+        }
+    }
+    // Hub modules: files that import many others (>15)
+    for (const [file, count] of importerCounts) {
+        if (count >= 15) {
+            modules.push({
+                file,
+                reason: 'hub',
+                metric: count,
+                description: `Imports ${count} modules - orchestrator/entry point, understand dependencies first`,
+            });
+        }
+    }
+    // Entry points: high importer count but low imported count
+    for (const [file, importCount] of importerCounts) {
+        const importedCount = importedCounts.get(file) ?? 0;
+        if (importCount >= 8 && importedCount <= 2) {
+            // Avoid duplicates
+            if (!modules.some(m => m.file === file && m.reason === 'entry_point')) {
+                modules.push({
+                    file,
+                    reason: 'entry_point',
+                    metric: importCount,
+                    description: `Likely entry point: imports ${importCount} modules but only imported by ${importedCount}`,
+                });
+            }
+        }
+    }
+    // Sort by metric descending, limit to top 10
+    return modules.sort((a, b) => b.metric - a.metric).slice(0, 10);
+}
 function parseRepoNormPath(bundleRelativePath) {
     const p = bundleRelativePath.replaceAll('\\', '/').replace(/^\/+/, '');
     const parts = p.split('/').filter(Boolean);
@@ -1196,6 +1309,10 @@ async function generateGlobalDependencyGraph(ctx) {
             timeBudgetMs,
         },
     };
+    // Generate high-value modules and Mermaid diagram
+    const nodesArray = Array.from(nodes.values());
+    const highValueModules = identifyHighValueModules(edges, nodesArray);
+    const mermaid = edges.length > 0 ? generateMermaidDiagram(edges, 15) : undefined;
     return {
         meta: {
             requestId,
@@ -1216,7 +1333,7 @@ async function generateGlobalDependencyGraph(ctx) {
             },
         },
         facts: {
-            nodes: Array.from(nodes.values()),
+            nodes: nodesArray,
             edges,
         },
         signals: {
@@ -1228,8 +1345,10 @@ async function generateGlobalDependencyGraph(ctx) {
                 importEdges,
             },
             warnings,
+            highValueModules: highValueModules.length > 0 ? highValueModules : undefined,
         },
         coverageReport,
+        mermaid,
     };
 }
 /**

package/dist/mcp/cursor.js

@@ -0,0 +1,145 @@
+/**
+ * RFC v2: Cursor encoding/decoding for stable pagination.
+ *
+ * Cursors are opaque, base64-encoded JSON objects that contain:
+ * - offset: The position in the result set
+ * - sortKey: The last seen sort key for stable ordering
+ * - tool: The tool that generated the cursor (for validation)
+ * - timestamp: When the cursor was created (for expiration)
+ *
+ * This enables LLMs to reliably paginate through large result sets.
+ */
+/**
+ * Maximum cursor age in milliseconds (24 hours).
+ * Cursors older than this are considered expired.
+ */
+const MAX_CURSOR_AGE_MS = 24 * 60 * 60 * 1000;
+/**
+ * Encode cursor state to an opaque string.
+ */
+export function encodeCursor(state) {
+    const json = JSON.stringify(state);
+    // Use base64url encoding (URL-safe, no padding)
+    return Buffer.from(json, 'utf8').toString('base64url');
+}
+/**
+ * Decode cursor string to cursor state.
+ * Returns null if the cursor is invalid.
+ */
+export function decodeCursor(cursor) {
+    try {
+        const json = Buffer.from(cursor, 'base64url').toString('utf8');
+        const state = JSON.parse(json);
+        // Validate structure
+        if (typeof state !== 'object' ||
+            state === null ||
+            typeof state.offset !== 'number' ||
+            typeof state.tool !== 'string' ||
+            typeof state.timestamp !== 'number') {
+            return null;
+        }
+        return state;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Validate a cursor for a specific tool.
+ * Checks structure, tool match, and expiration.
+ */
+export function validateCursor(cursor, expectedTool, options) {
+    const state = decodeCursor(cursor);
+    if (!state) {
+        return {
+            valid: false,
+            error: 'Invalid cursor format',
+        };
+    }
+    // Check tool match
+    if (!options?.allowToolMismatch && state.tool !== expectedTool) {
+        return {
+            valid: false,
+            state,
+            error: `Cursor was created by ${state.tool}, not ${expectedTool}`,
+        };
+    }
+    // Check expiration
+    const maxAge = options?.maxAgeMs ?? MAX_CURSOR_AGE_MS;
+    const age = Date.now() - state.timestamp;
+    if (age > maxAge) {
+        return {
+            valid: false,
+            state,
+            error: `Cursor expired (age: ${Math.round(age / 1000)}s, max: ${Math.round(maxAge / 1000)}s)`,
+        };
+    }
+    return {
+        valid: true,
+        state,
+    };
+}
+/**
+ * Create a cursor for the next page of results.
+ *
+ * @param tool - The tool creating the cursor
+ * @param offset - Current offset (will be incremented by pageSize)
+ * @param pageSize - Number of items per page
+ * @param sortKey - Optional sort key for keyset pagination
+ * @param extra - Optional additional data
+ */
+export function createNextCursor(tool, offset, pageSize, sortKey, extra) {
+    const state = {
+        offset: offset + pageSize,
+        tool,
+        timestamp: Date.now(),
+    };
+    if (sortKey !== undefined)
+        state.sortKey = sortKey;
+    if (extra !== undefined)
+        state.extra = extra;
+    return encodeCursor(state);
+}
+/**
+ * Parse cursor or return default offset.
+ * Convenience function for tool handlers.
+ *
+ * @param cursor - Optional cursor string
+ * @param tool - Expected tool name
+ * @param defaultOffset - Default offset if no cursor (default: 0)
+ * @returns Offset to use and any error message
+ */
+export function parseCursorOrDefault(cursor, tool, defaultOffset = 0) {
+    if (!cursor) {
+        return { offset: defaultOffset };
+    }
+    const validation = validateCursor(cursor, tool);
+    if (!validation.valid) {
+        return { offset: defaultOffset, error: validation.error };
+    }
+    return {
+        offset: validation.state.offset,
+        sortKey: validation.state.sortKey,
+        extra: validation.state.extra,
+    };
+}
+/**
+ * Helper to determine if pagination should continue.
+ *
+ * @param returnedCount - Number of items returned in this page
+ * @param limit - Requested limit
+ * @param totalCount - Optional total count (if known)
+ * @param currentOffset - Current offset in result set
+ */
+export function shouldPaginate(returnedCount, limit, totalCount, currentOffset = 0) {
+    // If we got fewer items than requested, we're at the end
+    if (returnedCount < limit) {
+        return false;
+    }
+    // If we know the total and have fetched everything, no more pages
+    if (totalCount !== undefined && currentOffset + returnedCount >= totalCount) {
+        return false;
+    }
+    // Otherwise, assume there might be more
+    return true;
+}

package/dist/mcp/envelope.js

@@ -0,0 +1,61 @@
+/**
+ * RFC v2: Unified Response Envelope for all Preflight MCP tools.
+ *
+ * This module defines the standardized response structure that enables:
+ * - LLM-friendly JSON output with stable field names
+ * - Evidence-first design with traceable citations
+ * - Pagination/truncation support with cursor-based continuation
+ * - Structured error handling with recovery hints
+ */
+/**
+ * Schema version for response envelope.
+ * Increment when making breaking changes to envelope structure.
+ */
+export const SCHEMA_VERSION = '2.0';
+/**
+ * Type guard to check if response is successful.
+ */
+export function isSuccessResponse(response) {
+    return response.ok === true && response.data !== undefined;
+}
+/**
+ * Type guard to check if response is an error.
+ */
+export function isErrorResponse(response) {
+    return response.ok === false && response.error !== undefined;
+}
+/**
+ * Helper to create a source range from line numbers.
+ */
+export function createRange(startLine, endLine, startCol, endCol) {
+    const range = { startLine, endLine };
+    if (startCol !== undefined)
+        range.startCol = startCol;
+    if (endCol !== undefined)
+        range.endCol = endCol;
+    return range;
+}
+/**
+ * Helper to create an evidence pointer.
+ */
+export function createEvidencePointer(path, range, options) {
+    const pointer = { path, range };
+    if (options?.uri)
+        pointer.uri = options.uri;
+    if (options?.snippet)
+        pointer.snippet = options.snippet;
+    if (options?.snippetSha256)
+        pointer.snippetSha256 = options.snippetSha256;
+    return pointer;
+}
+/**
+ * Format evidence pointer as citation string.
+ * Format: "path:startLine-endLine" or "path:line" for single line
+ */
+export function formatEvidenceCitation(pointer) {
+    const { path, range } = pointer;
+    if (range.startLine === range.endLine) {
+        return `${path}:${range.startLine}`;
+    }
+    return `${path}:${range.startLine}-${range.endLine}`;
+}

package/dist/mcp/errorKinds.js

@@ -72,6 +72,41 @@ const LLM_RECOVERY_HINTS = {
 This parameter is deprecated. The tool is now strictly read-only.
 - For updates: use preflight_update_bundle first, then retry
 - For repairs: use preflight_repair_bundle first, then retry`,
+    // RFC v2 additions
+    cursor_invalid: `💡 Recovery steps:
+1. The cursor format is invalid or corrupted
+2. Start fresh without a cursor to get the first page
+3. Use the nextCursor from the previous response exactly as provided`,
+    cursor_expired: `💡 Recovery steps:
+1. Cursors expire after 24 hours
+2. Start fresh without a cursor to get the first page
+3. Complete pagination within a reasonable time window`,
+    cursor_tool_mismatch: `💡 Recovery steps:
+1. The cursor was created by a different tool
+2. Use the cursor only with the same tool that created it
+3. Start fresh without a cursor for this tool`,
+    rate_limited: `💡 Recovery steps:
+1. You are making requests too quickly
+2. Wait a few seconds before retrying
+3. Consider batching multiple operations into single calls`,
+    timeout: `💡 Recovery steps:
+1. The operation took too long to complete
+2. Try with a smaller scope or limit
+3. Use cursor pagination to process in smaller batches`,
+    pagination_required: `💡 Note:
+The result set is large. Use cursor pagination:
+1. Check the 'truncation' field in the response
+2. Pass the 'nextCursor' value in subsequent calls
+3. Continue until truncated=false`,
+    validation_error: `💡 Recovery steps:
+1. Check that all required parameters are provided
+2. Verify parameter types match the schema
+3. Review the error message for specific field issues`,
+    partial_success: `💡 Note:
+Some operations succeeded but others failed:
+1. Check the 'warnings' array for details on failed items
+2. Address individual issues and retry failed items
+3. Successfully processed items are already applied`,
     unknown: `💡 If this error persists:
 1. Check the error message for specific details
 2. Verify your input parameters match the tool's schema

package/dist/mcp/pathRedaction.js

@@ -0,0 +1,180 @@
+/**
+ * Path redaction utilities for RFC v2.
+ *
+ * Provides functions to sanitize paths before returning them to LLM clients,
+ * removing sensitive information like usernames, home directories, etc.
+ */
+const DEFAULT_OPTIONS = {
+    redactUsername: true,
+    redactAbsolutePrefix: false,
+    customPatterns: [],
+    keepLastSegments: 0,
+};
+/**
+ * Common home directory patterns across platforms.
+ */
+const HOME_DIR_PATTERNS = [
+    // Windows: C:\Users\username\...
+    /^[A-Za-z]:\\Users\\[^\\]+\\/i,
+    // Linux/macOS: /home/username/... or /Users/username/...
+    /^\/(?:home|Users)\/[^/]+\//,
+    // WSL: /mnt/c/Users/username/...
+    /^\/mnt\/[a-z]\/Users\/[^/]+\//i,
+];
+/**
+ * Redact sensitive information from a file path.
+ *
+ * @param path - The file path to redact
+ * @param options - Redaction options
+ * @returns The redacted path
+ *
+ * @example
+ * redactPath('/Users/john/projects/myapp/src/main.ts')
+ * // Returns: '~/projects/myapp/src/main.ts'
+ *
+ * redactPath('C:\\Users\\john\\projects\\myapp\\src\\main.ts')
+ * // Returns: '~\\projects\\myapp\\src\\main.ts'
+ */
+export function redactPath(path, options = {}) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    let result = path;
+    // Apply username redaction
+    if (opts.redactUsername) {
+        for (const pattern of HOME_DIR_PATTERNS) {
+            result = result.replace(pattern, (match) => {
+                // Preserve the path separator style
+                return match.includes('\\') ? '~\\' : '~/';
+            });
+        }
+    }
+    // Apply absolute prefix redaction
+    if (opts.redactAbsolutePrefix) {
+        // Remove drive letters on Windows
+        result = result.replace(/^[A-Za-z]:/, '');
+        // Remove leading slash on Unix
+        result = result.replace(/^\//, '');
+    }
+    // Apply custom patterns
+    for (const { pattern, replacement } of opts.customPatterns ?? []) {
+        result = result.replace(pattern, replacement);
+    }
+    // Keep only last N segments
+    if (opts.keepLastSegments && opts.keepLastSegments > 0) {
+        const separator = result.includes('\\') ? '\\' : '/';
+        const segments = result.split(/[/\\]/);
+        if (segments.length > opts.keepLastSegments) {
+            result = '...' + separator + segments.slice(-opts.keepLastSegments).join(separator);
+        }
+    }
+    return result;
+}
+/**
+ * Redact paths in an object recursively.
+ * Looks for common path-like keys: path, file, filePath, dir, directory, uri, etc.
+ *
+ * @param obj - Object to redact paths in
+ * @param options - Redaction options
+ * @returns New object with redacted paths
+ */
+export function redactPathsInObject(obj, options = {}) {
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+    if (typeof obj === 'string') {
+        // Check if it looks like a path
+        if (isLikelyPath(obj)) {
+            return redactPath(obj, options);
+        }
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(item => redactPathsInObject(item, options));
+    }
+    if (typeof obj === 'object') {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            if (isPathKey(key) && typeof value === 'string') {
+                result[key] = redactPath(value, options);
+            }
+            else {
+                result[key] = redactPathsInObject(value, options);
+            }
+        }
+        return result;
+    }
+    return obj;
+}
+/**
+ * Check if a key name typically contains a path value.
+ */
+function isPathKey(key) {
+    const pathKeys = [
+        'path',
+        'file',
+        'filePath',
+        'filepath',
+        'dir',
+        'directory',
+        'folder',
+        'rootDir',
+        'rootPath',
+        'absPath',
+        'absolutePath',
+        'relativePath',
+        'relPath',
+        'bundleRoot',
+        'storageDir',
+        'configPath',
+    ];
+    const lowerKey = key.toLowerCase();
+    return pathKeys.some(pk => lowerKey === pk.toLowerCase() || lowerKey.endsWith(pk.toLowerCase()));
+}
+/**
+ * Check if a string looks like a file path.
+ */
+function isLikelyPath(str) {
+    // Check for common path patterns
+    return (
+    // Windows path: C:\...
+    /^[A-Za-z]:[/\\]/.test(str) ||
+        // Unix absolute path: /...
+        str.startsWith('/') ||
+        // Contains multiple path separators
+        (str.includes('/') && str.split('/').length > 2) ||
+        (str.includes('\\') && str.split('\\').length > 2));
+}
+/**
+ * Create a redaction function with preset options.
+ *
+ * @param options - Default options for the redactor
+ * @returns A redactPath function with the given options preset
+ */
+export function createRedactor(options) {
+    return (path) => redactPath(path, options);
+}
+/**
+ * Check if a path appears to contain sensitive information.
+ *
+ * @param path - Path to check
+ * @returns True if the path might contain sensitive info
+ */
+export function containsSensitiveInfo(path) {
+    // Check for home directory patterns
+    for (const pattern of HOME_DIR_PATTERNS) {
+        if (pattern.test(path)) {
+            return true;
+        }
+    }
+    // Check for other potentially sensitive patterns
+    const sensitivePatterns = [
+        /\.ssh\//i,
+        /\.gnupg\//i,
+        /\.aws\//i,
+        /\.azure\//i,
+        /credentials/i,
+        /secrets?/i,
+        /private/i,
+        /\.env$/i,
+    ];
+    return sensitivePatterns.some(p => p.test(path));
+}