clavix 7.2.2 → 7.3.0

package/dist/clean/discovery.js

@@ -0,0 +1,351 @@
+/**
+ * Discovery module for finding Clavix artifacts
+ */
+import path from 'node:path';
+import { DocInjector } from '../core/doc-injector.js';
+import { FileSystem } from '../utils/file-system.js';
+import { CLAVIX_BLOCK_START, CLAVIX_BLOCK_END } from '../constants.js';
+import { getKnownBlockFiles } from './guards.js';
+/**
+ * Known integration directories that may contain Clavix command files
+ */
+const INTEGRATION_DIRS = [
+    '.claude/commands',
+    '.claude/commands/clavix',
+    '.gemini/commands',
+    '.gemini/commands/clavix',
+    '.qwen/commands',
+    '.qwen/commands/clavix',
+    '.llxprt/commands',
+    '.llxprt/commands/clavix',
+];
+/**
+ * Discovery class for finding Clavix artifacts in a project
+ */
+export class Discovery {
+    /**
+     * Find all Clavix artifacts in a specific location
+     * @param rootPath - The root path to search
+     * @returns Array of CleanTarget objects
+     */
+    static async findArtifacts(rootPath) {
+        const targets = [];
+        // 1. Check for .clavix/ directory
+        const clavixDir = path.join(rootPath, '.clavix');
+        if (await FileSystem.exists(clavixDir)) {
+            const size = await this.getDirectorySize(clavixDir);
+            targets.push({
+                type: 'directory',
+                path: path.relative(rootPath, clavixDir) + path.sep,
+                description: 'Clavix configuration directory',
+                size,
+            });
+        }
+        // 2. Scan known integration directories for clavix-* files
+        for (const relativeDir of INTEGRATION_DIRS) {
+            const integrationDir = path.join(rootPath, relativeDir);
+            const files = await this.findFilesStartingWith(integrationDir, 'clavix-');
+            for (const file of files) {
+                const size = await this.getFileSize(file);
+                targets.push({
+                    type: 'file',
+                    path: path.relative(rootPath, file),
+                    description: this.getFileDescription(file),
+                    size,
+                });
+            }
+            // Also check for clavix subdirectory itself
+            const clavixSubdir = path.join(rootPath, relativeDir);
+            if (integrationDir.endsWith('/clavix')) {
+                if ((await FileSystem.exists(clavixSubdir)) &&
+                    path.relative(rootPath, clavixSubdir) !== '.clavix') {
+                    const size = await this.getDirectorySize(clavixSubdir);
+                    targets.push({
+                        type: 'directory',
+                        path: path.relative(rootPath, clavixSubdir) + path.sep,
+                        description: 'Clavix commands directory',
+                        size,
+                    });
+                }
+            }
+        }
+        // 3. Check for <!-- CLAVIX:START --> blocks in known files
+        for (const blockFile of getKnownBlockFiles()) {
+            const blockFilePath = path.join(rootPath, blockFile);
+            if (await FileSystem.exists(blockFilePath)) {
+                if (await DocInjector.hasBlock(blockFilePath, CLAVIX_BLOCK_START, CLAVIX_BLOCK_END)) {
+                    const size = await this.getFileSize(blockFilePath);
+                    targets.push({
+                        type: 'block',
+                        path: path.relative(rootPath, blockFilePath),
+                        description: `Clavix documentation block in ${blockFile}`,
+                        size,
+                    });
+                }
+            }
+        }
+        // 4. Scan for using-clavix files in root
+        const usingClavixFiles = await this.findFilesStartingWith(rootPath, 'using-clavix');
+        for (const file of usingClavixFiles) {
+            if (path.dirname(file) === rootPath) {
+                const size = await this.getFileSize(file);
+                targets.push({
+                    type: 'file',
+                    path: path.relative(rootPath, file),
+                    description: 'Clavix using meta-skill',
+                    size,
+                });
+            }
+        }
+        // 5. Find integration files from config
+        const integrations = await this.loadIntegrations();
+        const integrationTargets = await this.findIntegrationArtifacts(rootPath, integrations);
+        targets.push(...integrationTargets);
+        // 6. Check .skills/ directory for project-local skill directories
+        const skillsDir = path.join(rootPath, '.skills');
+        if (await FileSystem.exists(skillsDir)) {
+            const skillDirs = await this.findClavixSkillDirectories(skillsDir);
+            for (const skillDir of skillDirs) {
+                const size = await this.getDirectorySize(skillDir);
+                targets.push({
+                    type: 'directory',
+                    path: path.relative(rootPath, skillDir) + path.sep,
+                    description: `Clavix skill: ${path.basename(skillDir)}`,
+                    size,
+                });
+            }
+        }
+        // Sort targets by type (directories first, then files, then blocks)
+        const typePriority = { directory: 0, block: 1, file: 2 };
+        targets.sort((a, b) => typePriority[a.type] - typePriority[b.type]);
+        return targets;
+    }
+    /**
+     * Load integration configs from integrations.json
+     */
+    static async loadIntegrations() {
+        const fs = await import('node:fs/promises');
+        const configPath = path.join(process.cwd(), 'src/config/integrations.json');
+        try {
+            const config = JSON.parse(await fs.readFile(configPath, 'utf-8'));
+            return config.integrations || [];
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Find integration generated files dynamically
+     */
+    static async findIntegrationArtifacts(rootPath, integrations) {
+        const targets = [];
+        for (const integration of integrations) {
+            // Skip global integrations (handled in cleaner.ts)
+            if (integration.global)
+                continue;
+            // Skip universal integrations (they inject into files, handled separately)
+            if (integration.type === 'universal')
+                continue;
+            const targetDir = path.join(rootPath, integration.directory);
+            if (!(await FileSystem.exists(targetDir)))
+                continue;
+            // Find files matching the integration's pattern
+            const files = await this.findMatchingFiles(targetDir, integration);
+            for (const file of files) {
+                const size = await this.getFileSize(file);
+                targets.push({
+                    type: 'file',
+                    path: path.relative(rootPath, file),
+                    description: `Clavix (${integration.displayName}): ${path.basename(file)}`,
+                    size,
+                });
+            }
+        }
+        return targets;
+    }
+    /**
+     * Find files matching integration pattern
+     */
+    static async findMatchingFiles(dirPath, integration) {
+        const files = [];
+        const fs = await import('node:fs/promises');
+        try {
+            const dir = await fs.opendir(dirPath);
+            for await (const entry of dir) {
+                if (!entry.isFile())
+                    continue;
+                if (Discovery.fileMatchesIntegration(entry.name, integration)) {
+                    files.push(path.join(dirPath, entry.name));
+                }
+            }
+        }
+        catch {
+            // Directory doesn't exist or can't be read
+        }
+        return files;
+    }
+    /**
+     * Check if filename matches integration's pattern
+     */
+    static fileMatchesIntegration(filename, integration) {
+        const { filenamePattern, extension } = integration;
+        // Escape special regex characters in the pattern
+        const escapedPattern = filenamePattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        // Replace {name} with pattern matching any name
+        const namePattern = escapedPattern.replace('{name}', '.+');
+        // Handle patterns without {name} (static filenames like AGENTS)
+        const pattern = filenamePattern.includes('{name}')
+            ? `^${namePattern}\\${extension.replace('.', '\\.')}$`
+            : `^${escapedPattern}\\${extension.replace('.', '\\.')}$`;
+        return new RegExp(pattern).test(filename);
+    }
+    /**
+     * Find Clavix skill directories (.skills/clavix-*)
+     */
+    static async findClavixSkillDirectories(skillsDir) {
+        const dirs = [];
+        const fs = await import('node:fs/promises');
+        try {
+            const dir = await fs.opendir(skillsDir);
+            for await (const entry of dir) {
+                if (entry.isDirectory() && entry.name.startsWith('clavix-')) {
+                    dirs.push(path.join(skillsDir, entry.name));
+                }
+                // Also include using-clavix meta-skill directory
+                if (entry.isDirectory() && entry.name === 'using-clavix') {
+                    dirs.push(path.join(skillsDir, entry.name));
+                }
+            }
+        }
+        catch {
+            // Directory doesn't exist
+        }
+        return dirs;
+    }
+    /**
+     * Find files starting with a specific prefix in a directory
+     * @param dirPath - The directory to search
+     * @param prefix - The file prefix to match
+     * @returns Array of matching file paths
+     */
+    static async findFilesStartingWith(dirPath, prefix) {
+        const files = [];
+        try {
+            if (!(await FileSystem.exists(dirPath))) {
+                return files;
+            }
+            const fs = await import('node:fs/promises');
+            const dir = await fs.opendir(dirPath);
+            for await (const entry of dir) {
+                if (entry.isFile() && entry.name.startsWith(prefix)) {
+                    files.push(path.join(dirPath, entry.name));
+                }
+                else if (entry.isDirectory() && entry.name === 'clavix') {
+                    // Found a nested clavix directory, include it
+                    files.push(path.join(dirPath, entry.name, path.sep));
+                }
+            }
+        }
+        catch {
+            // If we can't read the directory, just return empty
+            // This is expected for non-existent or permission-denied directories
+        }
+        return files;
+    }
+    /**
+     * Get the size of a file in bytes
+     * @param filePath - The file path
+     * @returns File size in bytes
+     */
+    static async getFileSize(filePath) {
+        try {
+            const fs = await import('node:fs/promises');
+            const stats = await fs.stat(filePath);
+            return stats.size;
+        }
+        catch {
+            return 0;
+        }
+    }
+    /**
+     * Get the total size of a directory in bytes
+     * @param dirPath - The directory path
+     * @returns Total size in bytes
+     */
+    static async getDirectorySize(dirPath) {
+        let totalSize = 0;
+        try {
+            const fs = await import('node:fs/promises');
+            const dir = await fs.opendir(dirPath);
+            for await (const entry of dir) {
+                const entryPath = path.join(dirPath, entry.name);
+                if (entry.isFile()) {
+                    try {
+                        const stats = await fs.stat(entryPath);
+                        totalSize += stats.size;
+                    }
+                    catch {
+                        // Skip files we can't stat
+                    }
+                }
+                else if (entry.isDirectory()) {
+                    totalSize += await this.getDirectorySize(entryPath);
+                }
+            }
+        }
+        catch {
+            // If we can't read, just return 0
+        }
+        return totalSize;
+    }
+    /**
+     * Get a description for a file based on its name and location
+     * @param filePath - The file path
+     * @returns A human-readable description
+     */
+    static getFileDescription(filePath) {
+        const fileName = path.basename(filePath);
+        // Command files
+        if (fileName.startsWith('clavix-') && fileName.endsWith('.js')) {
+            const commandName = fileName.replace('clavix-', '').replace('.js', '');
+            return `Clavix command: ${commandName}`;
+        }
+        if (fileName.startsWith('clavix-') && fileName.endsWith('.ts')) {
+            const commandName = fileName.replace('clavix-', '').replace('.ts', '');
+            return `Clavix command: ${commandName}`;
+        }
+        // Generic clavix file
+        if (fileName.startsWith('clavix-')) {
+            return `Clavix file: ${fileName}`;
+        }
+        // using-clavix is a meta-skill
+        if (fileName.startsWith('using-clavix')) {
+            return 'Clavix meta-skill';
+        }
+        return `Clavix artifact: ${fileName}`;
+    }
+    /**
+     * Check if a directory is effectively empty (only contains .clavix)
+     * Used to determine if we should also remove empty parent directories
+     * @param dirPath - The directory to check
+     * @returns true if the directory is considered empty for cleanup purposes
+     */
+    static async isEmptyClavixParent(dirPath) {
+        try {
+            const fs = await import('node:fs/promises');
+            const dir = await fs.opendir(dirPath);
+            let hasOnlyClavix = true;
+            for await (const entry of dir) {
+                if (entry.name !== '.clavix') {
+                    hasOnlyClavix = false;
+                    break;
+                }
+            }
+            return hasOnlyClavix;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+//# sourceMappingURL=discovery.js.map

package/dist/clean/guards.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Safety guards for Clavix artifact detection
+ * Ensures only Clavix-related items are targeted for deletion
+ */
+/**
+ * Check if a filename follows Clavix naming conventions
+ * @param filename - The filename to check
+ * @returns true if the file appears to be Clavix-generated
+ */
+export declare function isClavixFile(filename: string): boolean;
+/**
+ * Check if a directory path is a known Clavix directory
+ * @param dirpath - The directory path to check
+ * @returns true if the directory is a Clavix-specific directory
+ */
+export declare function isClavixDirectory(dirpath: string): boolean;
+/**
+ * Check if a file is known to potentially contain Clavix documentation blocks
+ * @param filepath - The file path to check
+ * @returns true if the file may contain Clavix blocks
+ */
+export declare function isBlockFile(filepath: string): boolean;
+/**
+ * Check if a path should NEVER be deleted (forbidden patterns)
+ * @param filepath - The file or directory path to check
+ * @returns true if the path should be preserved
+ */
+export declare function isForbiddenPath(filepath: string): boolean;
+/**
+ * Comprehensive safety check - determines if a file can be deleted
+ * @param filepath - The file path to check
+ * @returns true if the file is safe to delete
+ */
+export declare function shouldDeleteFile(filepath: string): boolean;
+/**
+ * Expand a path pattern containing ~ to the actual home directory
+ * @param pattern - The path pattern to expand
+ * @returns The expanded path
+ */
+export declare function expandHomePath(pattern: string): string;
+/**
+ * Get the list of known Clavix directory patterns
+ * @returns Array of Clavix directory patterns
+ */
+export declare function getClavixDirectoryPatterns(): readonly string[];
+/**
+ * Get the list of files that may contain Clavix documentation blocks
+ * @returns Array of known block file names
+ */
+export declare function getKnownBlockFiles(): readonly string[];
+/**
+ * Get the list of file prefixes that indicate Clavix-generated files
+ * @returns Array of Clavix file prefixes
+ */
+export declare function getClavixFilePrefixes(): readonly string[];
+//# sourceMappingURL=guards.d.ts.map

package/dist/clean/guards.js

@@ -0,0 +1,182 @@
+/**
+ * Safety guards for Clavix artifact detection
+ * Ensures only Clavix-related items are targeted for deletion
+ */
+import path from 'node:path';
+import os from 'node:os';
+/**
+ * Clavix-specific patterns - ONLY items matching these are considered safe to delete
+ */
+const CLAVIX_PATTERNS = {
+    // Directories that contain only Clavix artifacts
+    directories: [
+        '.clavix',
+        '.claude/commands/clavix',
+        '.gemini/commands/clavix',
+        '.qwen/commands/clavix',
+        '.llxprt/commands/clavix',
+        '~/.config/agents/skills/clavix',
+        '~/.codex/prompts/clavix',
+        '~/.gemini/commands/clavix',
+        '~/.qwen/commands/clavix',
+        '~/.llxprt/commands/clavix',
+    ],
+    // File prefixes that indicate Clavix-generated files
+    filePrefixes: ['clavix-', 'using-clavix'],
+    // Content markers for documentation blocks
+    markers: ['<!-- CLAVIX:START -->', '<!-- CLAVIX:END -->'],
+    // Files that may contain Clavix documentation blocks
+    blockFiles: ['AGENTS.md', 'CLAUDE.md', 'OCTO.md', 'WARP.md', '.github/copilot-instructions.md'],
+    // Forbidden patterns - never delete files matching these
+    forbidden: [
+        'package.json',
+        'package-lock.json',
+        'yarn.lock',
+        'pnpm-lock.yaml',
+        '.git/',
+        'node_modules/',
+        '.npm/',
+        '.yarn/',
+        'README.md',
+        'LICENSE',
+        'tsconfig.json',
+    ],
+};
+/**
+ * Check if a filename follows Clavix naming conventions
+ * @param filename - The filename to check
+ * @returns true if the file appears to be Clavix-generated
+ */
+export function isClavixFile(filename) {
+    if (!filename) {
+        return false;
+    }
+    const baseName = path.basename(filename);
+    // Check file prefixes
+    for (const prefix of CLAVIX_PATTERNS.filePrefixes) {
+        if (baseName.startsWith(prefix)) {
+            return true;
+        }
+    }
+    // Check if in a clavix-specific directory
+    const dirPath = path.dirname(filename);
+    for (const pattern of CLAVIX_PATTERNS.directories) {
+        if (dirPath.includes(pattern.replace('~', os.homedir()))) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Check if a directory path is a known Clavix directory
+ * @param dirpath - The directory path to check
+ * @returns true if the directory is a Clavix-specific directory
+ */
+export function isClavixDirectory(dirpath) {
+    if (!dirpath) {
+        return false;
+    }
+    const normalizedPath = path.normalize(dirpath);
+    for (const pattern of CLAVIX_PATTERNS.directories) {
+        const expandedPattern = pattern.replace('~', os.homedir());
+        const normalizedPattern = path.normalize(expandedPattern);
+        // Check if path is or ends with the pattern
+        if (normalizedPath === normalizedPattern ||
+            normalizedPath.endsWith(path.sep + normalizedPattern) ||
+            normalizedPath.endsWith(path.normalize(path.sep + pattern))) {
+            return true;
+        }
+        // Check for wildcard matches (clavix-*)
+        if (pattern.includes('clavix-*')) {
+            const baseDir = path.dirname(expandedPattern);
+            const dirName = path.basename(normalizedPath);
+            if (normalizedPath.startsWith(baseDir) && dirName.startsWith('clavix-')) {
+                return true;
+            }
+        }
+    }
+    // Check .clavix directory directly
+    const pathParts = normalizedPath.split(path.sep);
+    return pathParts.includes('.clavix');
+}
+/**
+ * Check if a file is known to potentially contain Clavix documentation blocks
+ * @param filepath - The file path to check
+ * @returns true if the file may contain Clavix blocks
+ */
+export function isBlockFile(filepath) {
+    const baseName = path.basename(filepath);
+    return CLAVIX_PATTERNS.blockFiles.includes(baseName);
+}
+/**
+ * Check if a path should NEVER be deleted (forbidden patterns)
+ * @param filepath - The file or directory path to check
+ * @returns true if the path should be preserved
+ */
+export function isForbiddenPath(filepath) {
+    const normalizedPath = path.normalize(filepath);
+    const baseName = path.basename(normalizedPath);
+    // Check exact filename matches
+    if (CLAVIX_PATTERNS.forbidden.includes(baseName)) {
+        return true;
+    }
+    // Check if path contains forbidden directories
+    for (const forbidden of CLAVIX_PATTERNS.forbidden) {
+        if (forbidden.endsWith('/') &&
+            (normalizedPath.includes(forbidden) || normalizedPath.includes(path.normalize(forbidden)))) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Comprehensive safety check - determines if a file can be deleted
+ * @param filepath - The file path to check
+ * @returns true if the file is safe to delete
+ */
+export function shouldDeleteFile(filepath) {
+    const normalizedPath = path.normalize(filepath);
+    // Check against forbidden paths first
+    if (isForbiddenPath(normalizedPath)) {
+        return false;
+    }
+    // If it's a Clavix file, it's safe
+    if (isClavixFile(normalizedPath)) {
+        return true;
+    }
+    // If it's within the target root and is a Clavix directory, it's safe
+    if (isClavixDirectory(normalizedPath)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Expand a path pattern containing ~ to the actual home directory
+ * @param pattern - The path pattern to expand
+ * @returns The expanded path
+ */
+export function expandHomePath(pattern) {
+    return pattern.replace(/^~(?=$|\/|\\)/, os.homedir());
+}
+/**
+ * Get the list of known Clavix directory patterns
+ * @returns Array of Clavix directory patterns
+ */
+export function getClavixDirectoryPatterns() {
+    return CLAVIX_PATTERNS.directories;
+}
+/**
+ * Get the list of files that may contain Clavix documentation blocks
+ * @returns Array of known block file names
+ */
+export function getKnownBlockFiles() {
+    return CLAVIX_PATTERNS.blockFiles;
+}
+/**
+ * Get the list of file prefixes that indicate Clavix-generated files
+ * @returns Array of Clavix file prefixes
+ */
+export function getClavixFilePrefixes() {
+    return CLAVIX_PATTERNS.filePrefixes;
+}
+//# sourceMappingURL=guards.js.map

package/dist/clean/prompts.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Interactive prompts for the clean command
+ */
+import type { BatchInfo } from './types.js';
+import { CleanScope, ScanMethod } from './types.js';
+/**
+ * Result of a batch confirmation action
+ */
+export type BatchAction = 'delete' | 'details' | 'skip' | 'cancel';
+/**
+ * Prompts class for interactive user input
+ */
+export declare class Prompts {
+    /**
+     * Ask user what scope to clean
+     * @returns The selected clean scope
+     */
+    static selectScope(): Promise<CleanScope>;
+    /**
+     * Ask user how to discover projects with Clavix artifacts
+     * @returns The selected scan method
+     */
+    static selectScanMethod(): Promise<ScanMethod>;
+    /**
+     * Ask user to confirm deletion of a batch
+     * @param batch - The batch information to confirm
+     * @param dryRun - Whether this is a dry run
+     * @returns true if the user wants to delete, false to skip
+     */
+    static confirmBatch(batch: BatchInfo, dryRun?: boolean): Promise<boolean>;
+    /**
+     * Generate the confirmation message for a batch
+     */
+    private static getBatchMessage;
+    /**
+     * Get choices for batch confirmation
+     */
+    private static getBatchChoices;
+    /**
+     * Show detailed information about a batch
+     */
+    private static showBatchDetails;
+    /**
+     * Ask user to confirm scanning all directories (warning)
+     * @returns true if user wants to proceed
+     */
+    static confirmScanWarning(): Promise<boolean>;
+    /**
+     * Get custom paths from user
+     * @returns Array of paths to scan
+     */
+    static getCustomPaths(): Promise<string[]>;
+    /**
+     * Notify user that no artifacts were found
+     * @param scope - The scope that was checked
+     */
+    static notifyNoArtifacts(_scope: CleanScope): void;
+    /**
+     * Format size in human-readable format
+     */
+    private static formatSize;
+    /**
+     * Calculate total size of a batch
+     */
+    private static calculateBatchSize;
+}
+//# sourceMappingURL=prompts.d.ts.map