@defai.digital/ax-cli 4.4.6 → 4.4.10

package/dist/tools/registry.js

@@ -1,171 +0,0 @@
-/**
- * Tool Registry for dynamic tool management
- *
- * Provides a centralized registry for tools, enabling:
- * - Dynamic tool registration/unregistration
- * - Dependency validation
- * - Category-based organization
- * - Custom tool development
- */
-import { Ok, Err } from '../mcp/type-safety.js';
-import { extractErrorMessage } from '../utils/error-handler.js';
-/**
- * Tool Registry for dynamic tool management
- *
- * @example
- * ```typescript
- * const registry = new ToolRegistry();
- *
- * registry.register({
- *   name: 'my_tool',
- *   description: 'Does something',
- *   version: '1.0.0',
- *   category: 'custom',
- *   async execute(args) {
- *     return { success: true, output: 'Done!' };
- *   },
- *   schema: {
- *     type: 'object',
- *     properties: {
- *       input: { type: 'string' }
- *     }
- *   }
- * });
- * ```
- */
-export class ToolRegistry {
-    tools = new Map();
-    /**
-     * Register a new tool
-     *
-     * Validates:
-     * - Tool name format (lowercase with underscores)
-     * - No duplicate names
-     * - All dependencies exist
-     * - Schema is valid
-     *
-     * @param tool Tool definition to register
-     * @returns Ok(void) on success, Err(Error) on failure
-     */
-    register(tool) {
-        // Validate tool name format
-        if (!tool.name || !/^[a-z][a-z0-9_]*$/.test(tool.name)) {
-            return Err(new Error(`Invalid tool name: ${tool.name}. Must be lowercase with underscores.`));
-        }
-        // Check for conflicts
-        if (this.tools.has(tool.name)) {
-            return Err(new Error(`Tool ${tool.name} already registered`));
-        }
-        // Validate dependencies exist
-        if (tool.dependencies) {
-            for (const dep of tool.dependencies) {
-                if (!this.tools.has(dep)) {
-                    return Err(new Error(`Missing dependency: ${dep} required by ${tool.name}`));
-                }
-            }
-        }
-        // Validate schema
-        if (!tool.schema || tool.schema.type !== 'object') {
-            return Err(new Error(`Tool ${tool.name} must have object schema`));
-        }
-        this.tools.set(tool.name, tool);
-        return Ok(undefined);
-    }
-    /**
-     * Unregister a tool
-     *
-     * Validates that no other tools depend on this tool before removal.
-     *
-     * @param name Tool name to unregister
-     * @returns Ok(void) on success, Err(Error) on failure
-     */
-    unregister(name) {
-        // Check if any tool depends on this
-        for (const [toolName, tool] of this.tools.entries()) {
-            if (tool.dependencies?.includes(name)) {
-                return Err(new Error(`Cannot remove ${name}: ${toolName} depends on it`));
-            }
-        }
-        if (!this.tools.delete(name)) {
-            return Err(new Error(`Tool ${name} not found`));
-        }
-        return Ok(undefined);
-    }
-    /**
-     * Get a tool by name
-     *
-     * @param name Tool name
-     * @returns Tool definition or undefined if not found
-     */
-    get(name) {
-        return this.tools.get(name);
-    }
-    /**
-     * List all tools, optionally filtered by category
-     *
-     * @param category Optional category filter
-     * @returns Array of tool definitions
-     */
-    list(category) {
-        const allTools = Array.from(this.tools.values());
-        if (category) {
-            return allTools.filter(t => t.category === category);
-        }
-        return allTools;
-    }
-    /**
-     * Convert registered tools to LLM tool format
-     *
-     * Transforms internal ToolDefinition format to OpenAI function calling format.
-     *
-     * @returns Array of LLM tools
-     */
-    toLLMTools() {
-        return Array.from(this.tools.values()).map(tool => ({
-            type: 'function',
-            function: {
-                name: tool.name,
-                description: `${tool.description} (v${tool.version})`,
-                parameters: tool.schema
-            }
-        }));
-    }
-    /**
-     * Execute a tool by name
-     *
-     * @param name Tool name
-     * @param args Tool arguments
-     * @returns Tool result
-     */
-    async execute(name, args) {
-        const tool = this.tools.get(name);
-        if (!tool) {
-            return {
-                success: false,
-                error: `Tool not found: ${name}`
-            };
-        }
-        try {
-            return await tool.execute(args);
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: extractErrorMessage(error)
-            };
-        }
-    }
-    /**
-     * Get tool count
-     */
-    get size() {
-        return this.tools.size;
-    }
-    /**
-     * Clear all tools
-     */
-    clear() {
-        this.tools.clear();
-    }
-}
-//# sourceMappingURL=registry.js.map

package/dist/tools/registry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/tools/registry.ts"],"names":[],"mappings":"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"}

package/dist/tools/search.d.ts

@@ -1,85 +0,0 @@
-import { ToolResult } from "../types/index.js";
-export interface SearchResult {
-    file: string;
-    line: number;
-    column: number;
-    text: string;
-    match: string;
-}
-export interface FileSearchResult {
-    path: string;
-    name: string;
-    score: number;
-}
-export interface UnifiedSearchResult {
-    type: "text" | "file";
-    file: string;
-    line?: number;
-    column?: number;
-    text?: string;
-    match?: string;
-    score?: number;
-}
-export declare class SearchTool {
-    private static readonly DEFAULT_MAX_RESULTS;
-    private static readonly MAX_RECURSION_DEPTH;
-    private static readonly MAX_DISPLAY_RESULTS;
-    private static readonly SCORE_EXACT_MATCH;
-    private static readonly SCORE_CONTAINS_MATCH;
-    private static readonly SCORE_PATH_MATCH;
-    private static readonly SCORE_FUZZY_BASE;
-    private static readonly SCORE_FUZZY_MIN;
-    private static readonly SKIP_DIRECTORIES;
-    private currentDirectory;
-    /**
-     * Unified search method that can search for text content or find files
-     */
-    search(query: string, options?: {
-        searchType?: "text" | "files" | "both";
-        includePattern?: string;
-        excludePattern?: string;
-        caseSensitive?: boolean;
-        wholeWord?: boolean;
-        regex?: boolean;
-        maxResults?: number;
-        fileTypes?: string[];
-        excludeFiles?: string[];
-        includeHidden?: boolean;
-    }): Promise<ToolResult>;
-    /**
-     * Execute ripgrep command with specified options using process pool (REQ-ARCH-002)
-     */
-    private executeRipgrep;
-    /**
-     * Type guard for ripgrep match data with proper type narrowing
-     */
-    private isRipgrepMatch;
-    /**
-     * Parse ripgrep JSON output into SearchResult objects with full type safety
-     */
-    private parseRipgrepOutput;
-    /**
-     * Find files by pattern using a simple file walking approach
-     */
-    private findFilesByPattern;
-    /**
-     * Calculate fuzzy match score for file names
-     */
-    private calculateFileScore;
-    /**
-     * Calculate fuzzy match score for character sequence matching
-     */
-    private calculateFuzzyScore;
-    /**
-     * Format unified search results for display
-     */
-    private formatUnifiedResults;
-    /**
-     * Update current working directory
-     */
-    setCurrentDirectory(directory: string): void;
-    /**
-     * Get current working directory
-     */
-    getCurrentDirectory(): string;
-}

package/dist/tools/search.js

@@ -1,430 +0,0 @@
-import fs from "fs-extra";
-import path from "path";
-import { getRipgrepPool } from "../utils/process-pool.js";
-import { sanitizeSearchQuery, validateRegexPattern } from "../utils/input-sanitizer.js";
-import { getAuditLogger, AuditCategory } from "../utils/audit-logger.js";
-import { extractErrorMessage } from "../utils/error-handler.js";
-import { TIMEOUT_CONFIG } from "../constants.js";
-export class SearchTool {
-    static DEFAULT_MAX_RESULTS = 50;
-    static MAX_RECURSION_DEPTH = 10;
-    static MAX_DISPLAY_RESULTS = 8;
-    static SCORE_EXACT_MATCH = 100;
-    static SCORE_CONTAINS_MATCH = 80;
-    static SCORE_PATH_MATCH = 60;
-    static SCORE_FUZZY_BASE = 40;
-    static SCORE_FUZZY_MIN = 10;
-    static SKIP_DIRECTORIES = [
-        "node_modules",
-        ".git",
-        ".svn",
-        ".hg",
-        "dist",
-        "build",
-        ".next",
-        ".cache",
-    ];
-    currentDirectory = process.cwd();
-    /**
-     * Unified search method that can search for text content or find files
-     */
-    async search(query, options = {}) {
-        try {
-            // REQ-SEC-007: Sanitize search query to prevent ReDoS and injection
-            const sanitizedQuery = sanitizeSearchQuery(query);
-            if (!sanitizedQuery.valid || !sanitizedQuery.value) {
-                // REQ-SEC-008: Audit log input validation failure
-                // Wrap in try/catch to prevent audit logging failures from masking validation errors
-                try {
-                    const auditLogger = getAuditLogger();
-                    auditLogger.logWarning({
-                        category: AuditCategory.INPUT_VALIDATION,
-                        action: 'search_query_validation_failed',
-                        resource: 'search_tool',
-                        outcome: 'failure',
-                        error: sanitizedQuery.error,
-                        details: { queryLength: query.length },
-                    });
-                }
-                catch {
-                    // Audit logging is secondary - continue with validation error response
-                }
-                return {
-                    success: false,
-                    error: `Invalid search query: ${sanitizedQuery.error}`,
-                };
-            }
-            // REDOS FIX: Always validate patterns that could be interpreted as regex
-            // Even in fixed-string mode, validate to prevent accidental regex usage
-            const regexValidation = validateRegexPattern(sanitizedQuery.value);
-            if (options.regex) {
-                // Strict validation when regex mode is explicitly enabled
-                if (!regexValidation.valid) {
-                    // REQ-SEC-008: Audit log ReDoS protection trigger
-                    // Wrap in try/catch to prevent audit logging failures from masking validation errors
-                    try {
-                        const auditLogger = getAuditLogger();
-                        auditLogger.logCritical({
-                            category: AuditCategory.INPUT_VALIDATION,
-                            action: 'redos_pattern_detected',
-                            resource: 'search_tool',
-                            outcome: 'failure',
-                            error: regexValidation.error,
-                            details: { pattern: sanitizedQuery.value },
-                        });
-                    }
-                    catch {
-                        // Audit logging is secondary - continue with validation error response
-                    }
-                    return {
-                        success: false,
-                        error: `Invalid regex pattern: ${regexValidation.error}`,
-                    };
-                }
-                // Log warnings if any
-                if (regexValidation.warnings && regexValidation.warnings.length > 0) {
-                    console.warn(`Search regex warnings: ${regexValidation.warnings.join(', ')}`);
-                }
-            }
-            else {
-                // REDOS FIX: In fixed-string mode, warn if pattern looks like dangerous regex
-                // This prevents accidental ReDoS if fixed-string flag is forgotten
-                // But skip warning for glob-like patterns (they have ** or {})
-                const looksLikeGlob = /\*\*|{[^}]+}/.test(sanitizedQuery.value);
-                if (!regexValidation.valid && !looksLikeGlob) {
-                    console.warn(`Search pattern contains regex metacharacters that could be dangerous: ${regexValidation.error}. ` +
-                        `Using fixed-string mode (safe), but pattern may not match as expected.`);
-                }
-            }
-            const searchType = options.searchType || "both";
-            const results = [];
-            // sanitizedQuery.value is guaranteed to exist after the validation check above
-            const cleanQuery = sanitizedQuery.value;
-            // Search for text content if requested
-            if (searchType === "text" || searchType === "both") {
-                const textResults = await this.executeRipgrep(cleanQuery, options);
-                results.push(...textResults.map((r) => ({
-                    type: "text",
-                    file: r.file,
-                    line: r.line,
-                    column: r.column,
-                    text: r.text,
-                    match: r.match,
-                })));
-            }
-            // Search for files if requested
-            if (searchType === "files" || searchType === "both") {
-                const fileResults = await this.findFilesByPattern(cleanQuery, options);
-                results.push(...fileResults.map((r) => ({
-                    type: "file",
-                    file: r.path,
-                    score: r.score,
-                })));
-            }
-            if (results.length === 0) {
-                return {
-                    success: true,
-                    output: `No results found for "${cleanQuery}"`,
-                };
-            }
-            const formattedOutput = this.formatUnifiedResults(results, cleanQuery, searchType);
-            return {
-                success: true,
-                output: formattedOutput,
-            };
-        }
-        catch (error) {
-            const errorMsg = extractErrorMessage(error);
-            return {
-                success: false,
-                error: `Search error: ${errorMsg}`,
-            };
-        }
-    }
-    /**
-     * Execute ripgrep command with specified options using process pool (REQ-ARCH-002)
-     */
-    async executeRipgrep(query, options) {
-        const args = [
-            "--json",
-            "--with-filename",
-            "--line-number",
-            "--column",
-            "--no-heading",
-            "--color=never",
-        ];
-        // Add case sensitivity
-        if (!options.caseSensitive) {
-            args.push("--ignore-case");
-        }
-        // Add whole word matching
-        if (options.wholeWord) {
-            args.push("--word-regexp");
-        }
-        // Add regex mode
-        if (!options.regex) {
-            args.push("--fixed-strings");
-        }
-        // Add max results limit
-        if (options.maxResults !== undefined) {
-            // Validate maxResults is a positive integer
-            if (!Number.isInteger(options.maxResults) || options.maxResults < 1) {
-                throw new Error(`maxResults must be a positive integer, got: ${options.maxResults}`);
-            }
-            args.push("--max-count", options.maxResults.toString());
-        }
-        // Add file type filters
-        // Note: ripgrep's --type only supports built-in types (js, py, rust, etc.)
-        // For custom extensions like tsx, we use --glob instead
-        if (options.fileTypes) {
-            const builtinTypes = new Set([
-                'js', 'ts', 'py', 'rust', 'go', 'java', 'c', 'cpp', 'cs', 'rb', 'php',
-                'html', 'css', 'json', 'xml', 'yaml', 'yml', 'md', 'txt', 'sh', 'sql'
-            ]);
-            options.fileTypes.forEach((type) => {
-                if (builtinTypes.has(type)) {
-                    args.push("--type", type);
-                }
-                else {
-                    // Use glob pattern for non-builtin types (tsx, jsx, vue, svelte, etc.)
-                    args.push("--glob", `*.${type}`);
-                }
-            });
-        }
-        // Add include pattern
-        if (options.includePattern) {
-            args.push("--glob", options.includePattern);
-        }
-        // Add exclude pattern
-        if (options.excludePattern) {
-            args.push("--glob", `!${options.excludePattern}`);
-        }
-        // Add exclude files
-        if (options.excludeFiles) {
-            options.excludeFiles.forEach((file) => {
-                args.push("--glob", `!${file}`);
-            });
-        }
-        // Respect gitignore and common ignore patterns
-        args.push("--no-require-git", "--follow", "--glob", "!.git/**", "--glob", "!node_modules/**", "--glob", "!.DS_Store", "--glob", "!*.log");
-        // Add query and search directory
-        args.push(query, this.currentDirectory);
-        // MEMORY LEAK FIX (REQ-ARCH-002): Use process pool instead of spawning directly
-        const pool = getRipgrepPool();
-        try {
-            const result = await pool.execute({
-                command: "rg",
-                args,
-                cwd: this.currentDirectory,
-                timeout: TIMEOUT_CONFIG.SEARCH_DEFAULT,
-            });
-            // Handle ripgrep exit codes: 0 = found, 1 = not found, others = error
-            if (result.exitCode === 0 || result.exitCode === 1) {
-                return this.parseRipgrepOutput(result.stdout);
-            }
-            else {
-                throw new Error(`Ripgrep failed with code ${result.exitCode}: ${result.stderr}`);
-            }
-        }
-        catch (error) {
-            throw error instanceof Error
-                ? error
-                : new Error(`Ripgrep execution failed: ${String(error)}`);
-        }
-    }
-    /**
-     * Type guard for ripgrep match data with proper type narrowing
-     */
-    isRipgrepMatch(parsed) {
-        if (typeof parsed !== 'object' || parsed === null)
-            return false;
-        const obj = parsed;
-        return (obj.type === 'match' &&
-            typeof obj.data?.path?.text === 'string' &&
-            typeof obj.data?.line_number === 'number' &&
-            typeof obj.data?.lines?.text === 'string');
-    }
-    /**
-     * Parse ripgrep JSON output into SearchResult objects with full type safety
-     */
-    parseRipgrepOutput(output) {
-        if (!output.trim())
-            return [];
-        const results = [];
-        const lines = output.trim().split("\n");
-        for (const line of lines) {
-            try {
-                const parsed = JSON.parse(line);
-                if (this.isRipgrepMatch(parsed)) {
-                    // TypeScript now knows parsed has the correct structure
-                    results.push({
-                        file: parsed.data.path.text,
-                        line: parsed.data.line_number,
-                        column: parsed.data.submatches?.[0]?.start ?? 0,
-                        text: parsed.data.lines.text.trim(),
-                        match: parsed.data.submatches?.[0]?.match?.text ?? '',
-                    });
-                }
-            }
-            catch {
-                // Skip invalid JSON lines
-                continue;
-            }
-        }
-        return results;
-    }
-    /**
-     * Find files by pattern using a simple file walking approach
-     */
-    async findFilesByPattern(pattern, options) {
-        const files = [];
-        const maxResults = options.maxResults || SearchTool.DEFAULT_MAX_RESULTS;
-        const searchPattern = pattern.toLowerCase(); // Cache once for all comparisons
-        const walkDir = async (dir, depth = 0) => {
-            // Early exit if we've found enough results or exceeded depth
-            if (files.length >= maxResults)
-                return;
-            if (depth > SearchTool.MAX_RECURSION_DEPTH)
-                return;
-            try {
-                const entries = await fs.readdir(dir, { withFileTypes: true });
-                // Separate files and directories for better search ordering
-                const fileEntries = [];
-                const dirEntries = [];
-                for (const entry of entries) {
-                    // Skip hidden files unless explicitly included
-                    if (!options.includeHidden && entry.name.startsWith(".")) {
-                        continue;
-                    }
-                    // Skip common directories
-                    if (entry.isDirectory() && SearchTool.SKIP_DIRECTORIES.includes(entry.name)) {
-                        continue;
-                    }
-                    if (entry.isFile()) {
-                        fileEntries.push(entry);
-                    }
-                    else if (entry.isDirectory()) {
-                        dirEntries.push(entry);
-                    }
-                }
-                // Process files first (better for finding matches quickly)
-                for (const entry of fileEntries) {
-                    if (files.length >= maxResults)
-                        return; // Early exit
-                    const fullPath = path.join(dir, entry.name);
-                    const relativePath = path.relative(this.currentDirectory, fullPath);
-                    // Apply exclude pattern
-                    if (options.excludePattern &&
-                        relativePath.includes(options.excludePattern)) {
-                        continue;
-                    }
-                    const score = this.calculateFileScore(entry.name, relativePath, searchPattern);
-                    if (score > 0) {
-                        files.push({
-                            path: relativePath,
-                            name: entry.name,
-                            score,
-                        });
-                    }
-                }
-                // Process directories last
-                for (const entry of dirEntries) {
-                    if (files.length >= maxResults)
-                        return; // Early exit before recursion
-                    const fullPath = path.join(dir, entry.name);
-                    const relativePath = path.relative(this.currentDirectory, fullPath);
-                    // Apply exclude pattern
-                    if (options.excludePattern &&
-                        relativePath.includes(options.excludePattern)) {
-                        continue;
-                    }
-                    await walkDir(fullPath, depth + 1);
-                }
-            }
-            catch {
-                // Skip directories we can't read
-            }
-        };
-        await walkDir(this.currentDirectory);
-        // Sort by score (descending) and return top results
-        return files.sort((a, b) => b.score - a.score).slice(0, maxResults);
-    }
-    /**
-     * Calculate fuzzy match score for file names
-     */
-    calculateFileScore(fileName, filePath, pattern) {
-        const lowerFileName = fileName.toLowerCase();
-        const lowerFilePath = filePath.toLowerCase();
-        // Exact matches get highest score
-        if (lowerFileName === pattern)
-            return SearchTool.SCORE_EXACT_MATCH;
-        if (lowerFileName.includes(pattern))
-            return SearchTool.SCORE_CONTAINS_MATCH;
-        if (lowerFilePath.includes(pattern))
-            return SearchTool.SCORE_PATH_MATCH;
-        // Fuzzy matching - check if all characters of pattern exist in order
-        return this.calculateFuzzyScore(lowerFileName, pattern, fileName.length);
-    }
-    /**
-     * Calculate fuzzy match score for character sequence matching
-     */
-    calculateFuzzyScore(text, pattern, originalLength) {
-        let patternIndex = 0;
-        for (let i = 0; i < text.length && patternIndex < pattern.length; i++) {
-            if (text[i] === pattern[patternIndex]) {
-                patternIndex++;
-            }
-        }
-        // All characters found in order - score based on how close they are
-        return patternIndex === pattern.length
-            ? Math.max(SearchTool.SCORE_FUZZY_MIN, SearchTool.SCORE_FUZZY_BASE - (originalLength - pattern.length))
-            : 0;
-    }
-    /**
-     * Format unified search results for display
-     */
-    formatUnifiedResults(results, query, _searchType) {
-        if (results.length === 0) {
-            return `No results found for "${query}"`;
-        }
-        let output = `Search results for "${query}":\n`;
-        // Build file set and per-file match counts in a single pass to avoid O(n²) filters
-        const allFiles = new Set();
-        const matchCounts = new Map();
-        for (const result of results) {
-            allFiles.add(result.file);
-            if (result.type === 'text') {
-                const current = matchCounts.get(result.file) ?? 0;
-                matchCounts.set(result.file, current + 1);
-            }
-        }
-        const fileList = Array.from(allFiles);
-        const displayLimit = SearchTool.MAX_DISPLAY_RESULTS;
-        // Show files in compact format
-        fileList.slice(0, displayLimit).forEach((file) => {
-            // Count matches in this file for text results
-            const matchCount = matchCounts.get(file) ?? 0;
-            const matchIndicator = matchCount > 0 ? ` (${matchCount} matches)` : "";
-            output += `  ${file}${matchIndicator}\n`;
-        });
-        // Show "+X more" if there are additional results
-        if (fileList.length > displayLimit) {
-            const remaining = fileList.length - displayLimit;
-            output += `  ... +${remaining} more\n`;
-        }
-        return output.trim();
-    }
-    /**
-     * Update current working directory
-     */
-    setCurrentDirectory(directory) {
-        this.currentDirectory = directory;
-    }
-    /**
-     * Get current working directory
-     */
-    getCurrentDirectory() {
-        return this.currentDirectory;
-    }
-}
-//# sourceMappingURL=search.js.map