qraft/dist/utils/manifestUtils.d.ts

A powerful CLI tool to qraft structured project setups from GitHub template repositories

import { BoxManifest } from '../types';
/**
 * Information about a directory containing a manifest
 */
export interface ManifestDirectoryInfo {
    /** Path to the directory */
    path: string;
    /** Path to the .qraft directory */
    qraftPath: string;
    /** Number of files in .qraft directory */
    fileCount: number;
    /** Total size of .qraft directory in bytes */
    totalSize: number;
    /** Last modified timestamp */
    lastModified: Date;
    /** Whether manifest.json exists */
    hasManifest: boolean;
    /** Whether metadata.json exists */
    hasMetadata: boolean;
}
/**
 * Disk usage information for .qraft directory
 */
export interface DiskUsage {
    /** Total size in bytes */
    totalSize: number;
    /** Total number of files */
    fileCount: number;
    /** Directory breakdown */
    directories: Array<{
        path: string;
        size: number;
        files: number;
    }>;
}
/**
 * Validation result for directory suitability
 */
export interface ValidationResult {
    /** Whether the directory is valid for manifest storage */
    isValid: boolean;
    /** Critical issues that prevent manifest storage */
    issues: string[];
    /** Warnings that should be considered */
    warnings: string[];
}
/**
 * Manifest file paths for a directory
 */
export interface ManifestPaths {
    /** Absolute path to target directory */
    targetDirectory: string;
    /** Absolute path to .qraft directory */
    qraftDirectory: string;
    /** Absolute path to manifest.json */
    manifestFile: string;
    /** Absolute path to metadata.json */
    metadataFile: string;
    /** Relative paths from target directory */
    relativePaths: {
        qraftDirectory: string;
        manifestFile: string;
        metadataFile: string;
    };
}
/**
 * Compatibility assessment result
 */
export interface CompatibilityResult {
    /** Compatibility level */
    compatibilityLevel: 'compatible' | 'warning' | 'incompatible';
    /** Whether an existing manifest was found */
    hasExistingManifest: boolean;
    /** Detailed validation result */
    validation: ValidationResult;
    /** Recommendations for the user */
    recommendations: string[];
}
/**
 * Constants for manifest storage
 */
export declare const MANIFEST_CONSTANTS: {
    readonly QRAFT_DIR: ".qraft";
    readonly MANIFEST_FILE: "manifest.json";
    readonly METADATA_FILE: "metadata.json";
};
/**
 * Utility functions for manifest path resolution and directory management
 */
export declare class ManifestUtils {
    /**
     * Get the .qraft directory path for a target directory
     * @param targetDirectory Target directory path
     * @returns string Path to .qraft directory
     */
    static getQraftDirectoryPath(targetDirectory: string): string;
    /**
     * Get the manifest.json file path for a target directory
     * @param targetDirectory Target directory path
     * @returns string Path to manifest.json file
     */
    static getManifestFilePath(targetDirectory: string): string;
    /**
     * Get the metadata.json file path for a target directory
     * @param targetDirectory Target directory path
     * @returns string Path to metadata.json file
     */
    static getMetadataFilePath(targetDirectory: string): string;
    /**
     * Ensure the .qraft directory exists in the target directory
     * @param targetDirectory Target directory path
     * @returns Promise<void>
     */
    static ensureQraftDirectory(targetDirectory: string): Promise<void>;
    /**
     * Check if .qraft directory exists in the target directory
     * @param targetDirectory Target directory path
     * @returns Promise<boolean> True if .qraft directory exists
     */
    static qraftDirectoryExists(targetDirectory: string): Promise<boolean>;
    /**
     * Check if manifest.json exists in the target directory
     * @param targetDirectory Target directory path
     * @returns Promise<boolean> True if manifest.json exists
     */
    static manifestFileExists(targetDirectory: string): Promise<boolean>;
    /**
     * Check if metadata.json exists in the target directory
     * @param targetDirectory Target directory path
     * @returns Promise<boolean> True if metadata.json exists
     */
    static metadataFileExists(targetDirectory: string): Promise<boolean>;
    /**
     * Check if both manifest and metadata files exist (complete local manifest)
     * @param targetDirectory Target directory path
     * @returns Promise<boolean> True if both files exist
     */
    static hasCompleteLocalManifest(targetDirectory: string): Promise<boolean>;
    /**
     * Validate manifest structure and required fields
     * @param manifest Manifest object to validate
     * @returns boolean True if manifest is valid
     * @throws Error if manifest is invalid with specific error message
     */
    static validateManifest(manifest: any): manifest is BoxManifest;
    /**
     * Read and parse manifest.json file with validation
     * @param targetDirectory Target directory path
     * @returns Promise<BoxManifest> Parsed and validated manifest
     * @throws Error if file doesn't exist, can't be parsed, or is invalid
     */
    static readManifestFile(targetDirectory: string): Promise<BoxManifest>;
    /**
     * Write manifest to manifest.json file with proper formatting
     * @param targetDirectory Target directory path
     * @param manifest Manifest to write
     * @returns Promise<void>
     */
    static writeManifestFile(targetDirectory: string, manifest: BoxManifest): Promise<void>;
    /**
     * Read metadata.json file
     * @param targetDirectory Target directory path
     * @returns Promise<any> Parsed metadata object
     * @throws Error if file doesn't exist or can't be parsed
     */
    static readMetadataFile(targetDirectory: string): Promise<any>;
    /**
     * Write metadata to metadata.json file
     * @param targetDirectory Target directory path
     * @param metadata Metadata object to write
     * @returns Promise<void>
     */
    static writeMetadataFile(targetDirectory: string, metadata: any): Promise<void>;
    /**
     * Remove the entire .qraft directory and all its contents
     * @param targetDirectory Target directory path
     * @returns Promise<void>
     */
    static removeQraftDirectory(targetDirectory: string): Promise<void>;
    /**
     * Get relative path from target directory to .qraft directory (for exclude patterns)
     * @param targetDirectory Target directory path
     * @returns string Relative path to .qraft directory
     */
    static getQraftDirectoryRelativePath(): string;
    /**
     * Check if a path is within the .qraft directory
     * @param filePath File path to check
     * @returns boolean True if path is within .qraft directory
     */
    static isQraftPath(filePath: string): boolean;
    /**
     * Get default exclude patterns that should include .qraft directory
     * @param existingExcludes Existing exclude patterns
     * @returns string[] Updated exclude patterns including .qraft
     */
    static getUpdatedExcludePatterns(existingExcludes?: string[]): string[];
    /**
     * Find all directories containing .qraft manifests within a parent directory
     * @param parentDirectory Parent directory to search
     * @param maxDepth Maximum depth to search (default: 3)
     * @returns Promise<string[]> Array of directories containing manifests
     */
    static findManifestDirectories(parentDirectory: string, maxDepth?: number): Promise<string[]>;
    /**
     * Get manifest directory info including size and file count
     * @param targetDirectory Directory to analyze
     * @returns Promise<ManifestDirectoryInfo | null> Directory info or null if no manifest
     */
    static getManifestDirectoryInfo(targetDirectory: string): Promise<ManifestDirectoryInfo | null>;
    /**
     * Resolve relative paths within manifest context
     * @param basePath Base directory path
     * @param relativePath Relative path to resolve
     * @returns string Resolved absolute path
     */
    static resolveManifestPath(basePath: string, relativePath: string): string;
    /**
     * Get relative path from one directory to another
     * @param from Source directory
     * @param to Target directory
     * @returns string Relative path
     */
    static getRelativePath(from: string, to: string): string;
    /**
     * Normalize path separators for cross-platform compatibility
     * @param filePath Path to normalize
     * @returns string Normalized path
     */
    static normalizePath(filePath: string): string;
    /**
     * Check if a path is safe (doesn't escape parent directory)
     * @param basePath Base directory
     * @param targetPath Path to check
     * @returns boolean True if path is safe
     */
    static isSafePath(basePath: string, targetPath: string): boolean;
    /**
     * Create backup of .qraft directory
     * @param targetDirectory Directory containing .qraft
     * @param backupSuffix Suffix for backup directory (default: timestamp)
     * @returns Promise<string> Path to backup directory
     */
    static backupQraftDirectory(targetDirectory: string, backupSuffix?: string): Promise<string>;
    /**
     * Restore .qraft directory from backup
     * @param targetDirectory Directory to restore to
     * @param backupPath Path to backup directory
     * @returns Promise<void>
     */
    static restoreQraftDirectory(targetDirectory: string, backupPath: string): Promise<void>;
    /**
     * Clean up old backup directories
     * @param targetDirectory Directory to clean
     * @param maxAge Maximum age in days (default: 30)
     * @returns Promise<string[]> Array of removed backup paths
     */
    static cleanupOldBackups(targetDirectory: string, maxAge?: number): Promise<string[]>;
    /**
     * Get disk usage for .qraft directory
     * @param targetDirectory Directory containing .qraft
     * @returns Promise<DiskUsage> Disk usage information
     */
    static getQraftDiskUsage(targetDirectory: string): Promise<DiskUsage>;
    /**
     * Validate that a directory is suitable for manifest storage
     * @param targetDirectory Directory to validate
     * @returns Promise<ValidationResult> Validation result with details
     */
    static validateDirectoryForManifest(targetDirectory: string): Promise<ValidationResult>;
    /**
     * Get manifest file paths for a given directory
     * @param targetDirectory Target directory
     * @returns ManifestPaths Object containing all relevant paths
     */
    static getManifestPaths(targetDirectory: string): ManifestPaths;
    /**
     * Check if a directory structure is compatible with manifest storage
     * @param targetDirectory Directory to check
     * @returns Promise<CompatibilityResult> Compatibility assessment
     */
    static checkManifestCompatibility(targetDirectory: string): Promise<CompatibilityResult>;
}
//# sourceMappingURL=manifestUtils.d.ts.map