trinity-method-sdk 2.0.0

package/dist/cli/utils/metrics/framework-detector.js

@@ -0,0 +1,120 @@
+/**
+ * Framework Detection Module
+ * Detects framework versions and package managers
+ * @module cli/utils/metrics/framework-detector
+ */
+import fs from 'fs-extra';
+import { execSync } from 'child_process';
+/**
+ * Detect React version from package.json
+ */
+async function detectReactVersion() {
+    if (!(await fs.pathExists('package.json')))
+        return 'Unknown';
+    const pkg = await fs.readJson('package.json');
+    if (pkg.dependencies?.react) {
+        return pkg.dependencies.react.replace(/[\^~]/, '');
+    }
+    return detectNodeVersion();
+}
+/**
+ * Detect Next.js version from package.json
+ */
+async function detectNextVersion() {
+    if (!(await fs.pathExists('package.json')))
+        return 'Unknown';
+    const pkg = await fs.readJson('package.json');
+    if (pkg.dependencies?.next) {
+        return pkg.dependencies.next.replace(/[\^~]/, '');
+    }
+    return detectNodeVersion();
+}
+/**
+ * Detect Node.js version
+ */
+function detectNodeVersion() {
+    const nodeVersion = execSync('node --version', {
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'ignore'],
+    });
+    return nodeVersion.trim();
+}
+/**
+ * Detect Flutter version from pubspec.yaml
+ */
+async function detectFlutterVersion() {
+    if (!(await fs.pathExists('pubspec.yaml')))
+        return 'Unknown';
+    const yaml = await fs.readFile('pubspec.yaml', 'utf8');
+    const match = yaml.match(/sdk:\s*["']>=?(\d+\.\d+\.\d+)/);
+    return match ? match[1] : 'Unknown';
+}
+/**
+ * Detect Python version
+ */
+function detectPythonVersion() {
+    const version = execSync('python --version 2>&1', {
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'ignore'],
+    });
+    return version.trim().replace('Python ', '');
+}
+/**
+ * Detect Rust version
+ */
+function detectRustVersion() {
+    const version = execSync('rustc --version', {
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'ignore'],
+    });
+    return version.trim().replace('rustc ', '');
+}
+/**
+ * Framework version detector map
+ */
+const VERSION_DETECTORS = {
+    React: detectReactVersion,
+    'Next.js': detectNextVersion,
+    'Node.js': detectNodeVersion,
+    Flutter: detectFlutterVersion,
+    Python: detectPythonVersion,
+    Rust: detectRustVersion,
+};
+/**
+ * Detect framework version
+ * @param framework - Framework name
+ * @returns Version string
+ */
+export async function detectFrameworkVersion(framework) {
+    try {
+        const detector = VERSION_DETECTORS[framework];
+        if (detector) {
+            return await detector();
+        }
+    }
+    catch {
+        // Framework version detection failed
+    }
+    return 'Unknown';
+}
+/**
+ * Detect package manager
+ * @returns Package manager name
+ */
+export async function detectPackageManager() {
+    // Check in priority order (pnpm should be checked before npm/yarn)
+    if (await fs.pathExists('pnpm-lock.yaml'))
+        return 'pnpm';
+    if (await fs.pathExists('yarn.lock'))
+        return 'yarn';
+    if (await fs.pathExists('package-lock.json'))
+        return 'npm';
+    if (await fs.pathExists('pubspec.yaml'))
+        return 'pub';
+    if (await fs.pathExists('requirements.txt'))
+        return 'pip';
+    if (await fs.pathExists('Cargo.toml'))
+        return 'cargo';
+    return 'Unknown';
+}
+//# sourceMappingURL=framework-detector.js.map

package/dist/cli/utils/metrics/git-metrics.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Git Metrics Collection
+ * Collects commit counts, contributor counts, and last commit date
+ * @module cli/utils/metrics/git-metrics
+ */
+/**
+ * Get total commit count
+ * @returns Commit count
+ */
+export declare function getCommitCount(): Promise<number>;
+/**
+ * Get contributor count
+ * @returns Contributor count
+ */
+export declare function getContributorCount(): Promise<number>;
+/**
+ * Get last commit date
+ * @returns Last commit date (ISO format)
+ */
+export declare function getLastCommitDate(): Promise<string>;
+/**
+ * Collect git metrics
+ * @returns Git metrics
+ */
+export declare function collectGitMetrics(): Promise<{
+    commitCount: number;
+    contributors: number;
+    lastCommitDate: string;
+}>;
+//# sourceMappingURL=git-metrics.d.ts.map

package/dist/cli/utils/metrics/git-metrics.js

@@ -0,0 +1,83 @@
+/**
+ * Git Metrics Collection
+ * Collects commit counts, contributor counts, and last commit date
+ * @module cli/utils/metrics/git-metrics
+ */
+import { execSync } from 'child_process';
+/**
+ * Get total commit count
+ * @returns Commit count
+ */
+export async function getCommitCount() {
+    try {
+        const count = execSync('git rev-list --count HEAD', {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'ignore'],
+        });
+        return parseInt(count.trim(), 10);
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Get contributor count
+ * @returns Contributor count
+ */
+export async function getContributorCount() {
+    try {
+        const output = execSync('git shortlog -sn --all', {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'ignore'],
+        });
+        const lines = output
+            .trim()
+            .split('\n')
+            .filter((line) => line.length > 0);
+        return lines.length;
+    }
+    catch {
+        return 1;
+    }
+}
+/**
+ * Get last commit date
+ * @returns Last commit date (ISO format)
+ */
+export async function getLastCommitDate() {
+    try {
+        const date = execSync('git log -1 --format=%cI', {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'ignore'],
+        });
+        return date.trim();
+    }
+    catch {
+        return 'Unknown';
+    }
+}
+/**
+ * Collect git metrics
+ * @returns Git metrics
+ */
+export async function collectGitMetrics() {
+    try {
+        const commitCount = await getCommitCount();
+        const contributors = await getContributorCount();
+        const lastCommitDate = await getLastCommitDate();
+        return {
+            commitCount,
+            contributors,
+            lastCommitDate,
+        };
+    }
+    catch {
+        // Git not available or not a git repo
+        return {
+            commitCount: 0,
+            contributors: 0,
+            lastCommitDate: 'Unknown',
+        };
+    }
+}
+//# sourceMappingURL=git-metrics.js.map

package/dist/cli/utils/metrics/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Codebase Metrics Collection Utility - Main Orchestrator
+ * Trinity Method SDK - Hybrid Audit System
+ *
+ * Collects scriptable metrics from codebase without semantic analysis.
+ * Designed for cross-platform compatibility (Node.js, Flutter, React, Python, Rust).
+ * @module cli/utils/metrics
+ */
+import { CodebaseMetrics } from '../../types.js';
+import { analyzeFileComplexity } from './file-complexity.js';
+import { parseDependencies } from './dependency-parser.js';
+import { detectFrameworkVersion, detectPackageManager } from './framework-detector.js';
+/**
+ * Create an empty CodebaseMetrics object with default values
+ */
+export declare function createEmptyMetrics(): CodebaseMetrics;
+/**
+ * Main entry point for metrics collection
+ * @param sourceDir - Source code directory (src/, lib/, app/)
+ * @param framework - Detected framework (Node.js, Flutter, React, Python, Rust)
+ * @returns Collected metrics
+ */
+declare function collectCodebaseMetrics(sourceDir: string, framework: string): Promise<CodebaseMetrics>;
+export { collectCodebaseMetrics, analyzeFileComplexity, parseDependencies, detectFrameworkVersion, detectPackageManager, };
+export { countPattern } from './code-quality.js';
+export type { FileComplexityMetrics } from './file-complexity.js';
+export type { DependencyMetrics } from './dependency-parser.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/utils/metrics/index.js

@@ -0,0 +1,100 @@
+/**
+ * Codebase Metrics Collection Utility - Main Orchestrator
+ * Trinity Method SDK - Hybrid Audit System
+ *
+ * Collects scriptable metrics from codebase without semantic analysis.
+ * Designed for cross-platform compatibility (Node.js, Flutter, React, Python, Rust).
+ * @module cli/utils/metrics
+ */
+import { collectCodeQualityMetrics } from './code-quality.js';
+import { analyzeFileComplexity } from './file-complexity.js';
+import { parseDependencies } from './dependency-parser.js';
+import { collectGitMetrics } from './git-metrics.js';
+import { detectFrameworkVersion, detectPackageManager } from './framework-detector.js';
+/**
+ * Create an empty CodebaseMetrics object with default values
+ */
+export function createEmptyMetrics() {
+    return {
+        // Code Quality Metrics
+        todoCount: 0,
+        todoComments: 0,
+        fixmeComments: 0,
+        hackComments: 0,
+        consoleStatements: 0,
+        commentedCodeBlocks: 0,
+        // File Complexity Metrics
+        totalFiles: 0,
+        filesOver500: 0,
+        filesOver1000: 0,
+        filesOver3000: 0,
+        avgFileLength: 0,
+        largestFiles: [],
+        // Dependency Metrics
+        dependencies: {},
+        dependencyCount: 0,
+        devDependencies: {},
+        devDependencyCount: 0,
+        // Git Metrics
+        commitCount: 0,
+        contributors: 0,
+        lastCommitDate: 'Unknown',
+        // Framework-Specific
+        frameworkVersion: 'Unknown',
+        packageManager: 'Unknown',
+    };
+}
+/**
+ * Main entry point for metrics collection
+ * @param sourceDir - Source code directory (src/, lib/, app/)
+ * @param framework - Detected framework (Node.js, Flutter, React, Python, Rust)
+ * @returns Collected metrics
+ */
+async function collectCodebaseMetrics(sourceDir, framework) {
+    console.log(`   Collecting metrics from ${sourceDir} (${framework})...`);
+    const metrics = createEmptyMetrics();
+    try {
+        // Code Quality Metrics
+        const codeQuality = await collectCodeQualityMetrics(sourceDir);
+        Object.assign(metrics, codeQuality);
+        // File Complexity Metrics
+        const fileStats = await analyzeFileComplexity(sourceDir);
+        metrics.totalFiles = fileStats.totalFiles;
+        metrics.filesOver500 = fileStats.filesOver500;
+        metrics.filesOver1000 = fileStats.filesOver1000;
+        metrics.filesOver3000 = fileStats.filesOver3000;
+        metrics.avgFileLength = fileStats.avgFileLength;
+        metrics.largestFiles = fileStats.largestFiles;
+        // Dependency Metrics
+        const deps = await parseDependencies(framework);
+        metrics.dependencies = deps.dependencies;
+        metrics.dependencyCount = deps.dependencyCount;
+        metrics.devDependencies = deps.devDependencies;
+        metrics.devDependencyCount = deps.devDependencyCount;
+        // Git Metrics (optional)
+        try {
+            const gitMetrics = await collectGitMetrics();
+            metrics.commitCount = gitMetrics.commitCount;
+            metrics.contributors = gitMetrics.contributors;
+            metrics.lastCommitDate = gitMetrics.lastCommitDate;
+        }
+        catch {
+            // Git not available or not a git repo
+            console.log('   Git metrics unavailable (not a git repository)');
+        }
+        // Framework-Specific
+        metrics.frameworkVersion = await detectFrameworkVersion(framework);
+        metrics.packageManager = await detectPackageManager();
+    }
+    catch (error) {
+        const { displayError, getErrorMessage } = await import('../errors.js');
+        displayError(`Error collecting metrics: ${getErrorMessage(error)}`);
+        throw error;
+    }
+    return metrics;
+}
+// Export everything for backward compatibility
+export { collectCodebaseMetrics, analyzeFileComplexity, parseDependencies, detectFrameworkVersion, detectPackageManager, };
+// Re-export from submodules for direct access
+export { countPattern } from './code-quality.js';
+//# sourceMappingURL=index.js.map

package/dist/cli/utils/template-processor.d.ts

@@ -0,0 +1,10 @@
+import { Stack, CodebaseMetrics } from '../types.js';
+export declare function processTemplate(content: string, variables: Record<string, string | number>): string;
+export declare function extractVariables(stack: Stack, projectName: string): Record<string, string>;
+/**
+ * Format metrics for template variable replacement
+ * @param metrics - Collected codebase metrics
+ * @returns Formatted metric variables
+ */
+export declare function formatMetrics(metrics?: CodebaseMetrics): Record<string, string | number>;
+//# sourceMappingURL=template-processor.d.ts.map

package/dist/cli/utils/template-processor.js

@@ -0,0 +1,188 @@
+/**
+ * Convert value to string safely
+ */
+function toString(value) {
+    return value !== undefined ? String(value) : '';
+}
+/**
+ * Resolve PROJECT_VAR_NAME variable
+ */
+function resolveProjectVarName(variables) {
+    return (toString(variables.PROJECT_VAR_NAME) ||
+        String(variables.PROJECT_NAME || variables.projectName || 'project')
+            .toLowerCase()
+            .replace(/[^a-z0-9]/g, ''));
+}
+/**
+ * Variable resolvers - maps placeholder names to resolution functions
+ */
+const VARIABLE_RESOLVERS = {
+    PROJECT_NAME: (v) => toString(v.PROJECT_NAME || v.projectName) || 'Unknown Project',
+    TECH_STACK: (v) => toString(v.TECH_STACK || v.techStack) || 'Unknown',
+    FRAMEWORK: (v) => toString(v.FRAMEWORK || v.framework) || 'Generic',
+    SOURCE_DIR: (v) => toString(v.SOURCE_DIR || v.sourceDir) || 'src',
+    DEPLOYMENT_TIMESTAMP: (v) => toString(v.DEPLOYMENT_TIMESTAMP || v.timestamp) || new Date().toISOString(),
+    LANGUAGE: (v) => toString(v.LANGUAGE || v.language) || 'Unknown',
+    PACKAGE_MANAGER: (v) => toString(v.PACKAGE_MANAGER || v.packageManager) || 'npm',
+    TRINITY_VERSION: (v) => toString(v.TRINITY_VERSION) || '2.0.0',
+    TECHNOLOGY_STACK: (v) => toString(v.TECHNOLOGY_STACK || v.TECH_STACK || v.techStack) || 'Unknown',
+    PRIMARY_FRAMEWORK: (v) => toString(v.PRIMARY_FRAMEWORK || v.FRAMEWORK || v.framework) || 'Generic',
+    CURRENT_DATE: (v) => toString(v.CURRENT_DATE) || new Date().toISOString().split('T')[0],
+    PROJECT_VAR_NAME: (v) => resolveProjectVarName(v),
+    TRINITY_HOME: (v) => toString(v.TRINITY_HOME) ||
+        process.env.TRINITY_HOME ||
+        'C:/Users/lukaf/Desktop/Dev Work/trinity-method',
+};
+export function processTemplate(content, variables) {
+    let processed = content;
+    // Replace each placeholder using resolver functions
+    for (const [key, resolver] of Object.entries(VARIABLE_RESOLVERS)) {
+        const value = resolver(variables);
+        const regex = new RegExp(`\\{\\{${key}\\}\\}`, 'g');
+        processed = processed.replace(regex, value);
+    }
+    return processed;
+}
+export function extractVariables(stack, projectName) {
+    return {
+        projectName: projectName || 'My Project',
+        techStack: `${stack.language} / ${stack.framework}`,
+        framework: stack.framework,
+        sourceDir: stack.sourceDir,
+        language: stack.language,
+        packageManager: stack.packageManager || 'npm',
+        timestamp: new Date().toISOString(),
+    };
+}
+/**
+ * Get placeholder metrics object
+ */
+function getPlaceholderMetrics() {
+    return {
+        // Code Quality
+        TODO_COUNT: '{{TODO_COUNT}}',
+        TODO_COMMENTS: '{{TODO_COMMENTS}}',
+        FIXME_COUNT: '{{FIXME_COUNT}}',
+        HACK_COUNT: '{{HACK_COUNT}}',
+        CONSOLE_COUNT: '{{CONSOLE_COUNT}}',
+        COMMENTED_BLOCKS: '{{COMMENTED_BLOCKS}}',
+        // File Complexity
+        TOTAL_FILES: '{{TOTAL_FILES}}',
+        FILES_500: '{{FILES_500}}',
+        FILES_1000: '{{FILES_1000}}',
+        FILES_3000: '{{FILES_3000}}',
+        AVG_LENGTH: '{{AVG_LENGTH}}',
+        // Dependencies
+        DEPENDENCY_COUNT: '{{DEPENDENCY_COUNT}}',
+        DEV_DEPENDENCY_COUNT: '{{DEV_DEPENDENCY_COUNT}}',
+        FRAMEWORK_VERSION: '{{FRAMEWORK_VERSION}}',
+        PACKAGE_MANAGER: '{{PACKAGE_MANAGER}}',
+        // Git
+        COMMIT_COUNT: '{{COMMIT_COUNT}}',
+        CONTRIBUTOR_COUNT: '{{CONTRIBUTOR_COUNT}}',
+        LAST_COMMIT: '{{LAST_COMMIT}}',
+        // Agent-only
+        OVERALL_COVERAGE: '{{OVERALL_COVERAGE}}',
+        UNIT_COVERAGE: '{{UNIT_COVERAGE}}',
+        DEPRECATED_COUNT: '{{DEPRECATED_COUNT}}',
+        ANTIPATTERN_COUNT: '{{ANTIPATTERN_COUNT}}',
+        PERF_ISSUE_COUNT: '{{PERF_ISSUE_COUNT}}',
+        SECURITY_COUNT: '{{SECURITY_COUNT}}',
+        // Architecture
+        COMPONENT_1: '{{COMPONENT_1}}',
+        RESPONSIBILITY_1: '{{RESPONSIBILITY_1}}',
+        BACKEND_FRAMEWORK: '{{BACKEND_FRAMEWORK}}',
+        DATABASE_TYPE: '{{DATABASE_TYPE}}',
+        AUTH_TYPE: '{{AUTH_TYPE}}',
+        STYLING_SOLUTION: '{{STYLING_SOLUTION}}',
+    };
+}
+/**
+ * Get agent-only placeholder metrics
+ */
+function getAgentOnlyPlaceholders() {
+    return {
+        OVERALL_COVERAGE: '{{OVERALL_COVERAGE}}',
+        UNIT_COVERAGE: '{{UNIT_COVERAGE}}',
+        DEPRECATED_COUNT: '{{DEPRECATED_COUNT}}',
+        ANTIPATTERN_COUNT: '{{ANTIPATTERN_COUNT}}',
+        PERF_ISSUE_COUNT: '{{PERF_ISSUE_COUNT}}',
+        SECURITY_COUNT: '{{SECURITY_COUNT}}',
+        COMPONENT_1: '{{COMPONENT_1}}',
+        RESPONSIBILITY_1: '{{RESPONSIBILITY_1}}',
+        BACKEND_FRAMEWORK: '{{BACKEND_FRAMEWORK}}',
+        DATABASE_TYPE: '{{DATABASE_TYPE}}',
+        AUTH_TYPE: '{{AUTH_TYPE}}',
+        STYLING_SOLUTION: '{{STYLING_SOLUTION}}',
+    };
+}
+/**
+ * Format code quality metrics
+ */
+function formatCodeQualityMetrics(metrics) {
+    return {
+        TODO_COUNT: metrics.todoCount || 0,
+        TODO_COMMENTS: metrics.todoComments || 0,
+        FIXME_COUNT: metrics.fixmeComments || 0,
+        HACK_COUNT: metrics.hackComments || 0,
+        CONSOLE_COUNT: metrics.consoleStatements || 0,
+        COMMENTED_BLOCKS: metrics.commentedCodeBlocks || 0,
+    };
+}
+/**
+ * Format file complexity metrics
+ */
+function formatFileComplexityMetrics(metrics) {
+    return {
+        TOTAL_FILES: metrics.totalFiles || 0,
+        FILES_500: metrics.filesOver500 || 0,
+        FILES_1000: metrics.filesOver1000 || 0,
+        FILES_3000: metrics.filesOver3000 || 0,
+        AVG_LENGTH: Math.round(metrics.avgFileLength || 0),
+    };
+}
+/**
+ * Format dependency metrics
+ */
+function formatDependencyMetrics(metrics) {
+    return {
+        DEPENDENCY_COUNT: metrics.dependencyCount || 0,
+        DEV_DEPENDENCY_COUNT: metrics.devDependencyCount || 0,
+        FRAMEWORK_VERSION: metrics.frameworkVersion || 'Unknown',
+        PACKAGE_MANAGER: metrics.packageManager || 'Unknown',
+    };
+}
+/**
+ * Format git metrics
+ */
+function formatGitMetrics(metrics) {
+    return {
+        COMMIT_COUNT: metrics.commitCount || 0,
+        CONTRIBUTOR_COUNT: metrics.contributors || 1,
+        LAST_COMMIT: metrics.lastCommitDate || 'Unknown',
+    };
+}
+/**
+ * Format actual metrics from codebase
+ */
+function formatActualMetrics(metrics) {
+    return {
+        ...formatCodeQualityMetrics(metrics),
+        ...formatFileComplexityMetrics(metrics),
+        ...formatDependencyMetrics(metrics),
+        ...formatGitMetrics(metrics),
+        ...getAgentOnlyPlaceholders(),
+    };
+}
+/**
+ * Format metrics for template variable replacement
+ * @param metrics - Collected codebase metrics
+ * @returns Formatted metric variables
+ */
+export function formatMetrics(metrics) {
+    if (!metrics || Object.keys(metrics).length === 0) {
+        return getPlaceholderMetrics();
+    }
+    return formatActualMetrics(metrics);
+}
+//# sourceMappingURL=template-processor.js.map

package/dist/cli/utils/validate-path.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Path Validation Utility
+ * Security module for preventing path traversal and symlink attacks
+ * @module cli/utils/validate-path
+ */
+/**
+ * Validate that a path is safe and within project directory
+ *
+ * Security checks:
+ * - Rejects absolute paths (Unix: /path, Windows: C:\path, UNC: \\server\share)
+ * - Rejects path traversal attempts (../)
+ * - Normalizes path separators for cross-platform compatibility
+ * - Ensures resolved path is within baseDir
+ *
+ * @param userPath - User-provided path (potentially malicious)
+ * @param baseDir - Base directory (defaults to current working directory)
+ * @throws Error if path is invalid, absolute, or attempts traversal
+ * @returns Validated absolute path within baseDir
+ *
+ * @example
+ * ```typescript
+ * // Valid usage
+ * const safe = validatePath('trinity/agents'); // OK
+ * const safe2 = validatePath('./trinity/agents'); // OK
+ *
+ * // Blocked - path traversal
+ * validatePath('../../../etc/passwd'); // throws Error
+ *
+ * // Blocked - absolute path
+ * validatePath('/etc/passwd'); // throws Error
+ * validatePath('C:\\Windows\\System32'); // throws Error
+ * ```
+ */
+export declare function validatePath(userPath: string, baseDir?: string): string;
+/**
+ * Validate that a path is not a symlink
+ *
+ * Security rationale:
+ * - Prevents symlink attacks where malicious symlinks point to sensitive files
+ * - Ensures file operations act on actual files, not symlink references
+ * - Protects against symlink race conditions
+ *
+ * @param filePath - Path to validate (should be absolute path from validatePath)
+ * @throws Error if path is a symlink
+ *
+ * @example
+ * ```typescript
+ * await validateNotSymlink('/project/trinity/agents/mon.md'); // OK
+ * await validateNotSymlink('/project/link-to-passwd'); // throws Error
+ * ```
+ */
+export declare function validateNotSymlink(filePath: string): Promise<void>;
+/**
+ * Safely copy files or directories with security validation
+ *
+ * Security features:
+ * - Validates both source and destination paths
+ * - Rejects symlinks (prevents symlink attacks)
+ * - Doesn't follow symlinks during copy (dereference: false)
+ * - Ensures copy stays within project directory
+ *
+ * @param src - Source path (relative to baseDir)
+ * @param dest - Destination path (relative to baseDir)
+ * @param baseDir - Base directory (defaults to current working directory)
+ * @throws Error if paths are invalid or contain symlinks
+ *
+ * @example
+ * ```typescript
+ * // Safe copy
+ * await safeCopy('templates/agent.md', 'trinity/agents/new-agent.md');
+ *
+ * // Blocked - path traversal
+ * await safeCopy('file.txt', '../outside/file.txt'); // throws Error
+ *
+ * // Blocked - symlink source
+ * await safeCopy('symlink-to-file', 'dest.txt'); // throws Error
+ * ```
+ */
+export declare function safeCopy(src: string, dest: string, baseDir?: string): Promise<void>;
+//# sourceMappingURL=validate-path.d.ts.map