claude-flow-novice 2.15.11 → 2.16.0

package/claude-assets/skills/cfn-dependency-ingestion/dist/ingest-dependencies.js

@@ -0,0 +1,478 @@
+#!/usr/bin/env node
+/**
+ * CFN Dependency Ingestion - TypeScript Implementation
+ * Dynamically discovers and ingests CFN Loop CLI dependency files
+ *
+ * Features:
+ * - Dynamic file discovery from dependency diagram
+ * - Content injection mode (--inject-content) for atomic context loading
+ * - Token estimation with 25k safety limit
+ * - Priority filtering (P0, P1, P2)
+ * - Type filtering (TS, SH)
+ * - File existence validation
+ *
+ * Usage:
+ *   node ingest-dependencies.js [--inject-content] [--priority P0,P1] [--type TS,SH]
+ *
+ * Version: 2.0.0 (Enhancement #5: Content Injection Mode)
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+// Constants
+const PROJECT_ROOT = execSync('git rev-parse --show-toplevel', { encoding: 'utf-8' }).trim();
+const DIAGRAMS = {
+    cli: path.join(PROJECT_ROOT, 'readme/CFN_LOOP_DEPENDENCY_DIAGRAM.txt'),
+    docker: path.join(PROJECT_ROOT, 'readme/CFN_LOOP_DOCKER_DEPENDENCY_DIAGRAM.txt'),
+};
+const TOKEN_LIMIT = 25000; // 25k token safety limit (for single-file mode)
+const CHUNK_SIZE = 20000; // 20k tokens per chunk for multi-file mode
+const CHARS_PER_TOKEN = 4; // Rough estimation
+const TEMP_DIR = '/tmp/cfn-dependency-chunks'; // Temp directory for chunk files
+// Global state for current diagram (set during parseArgs)
+let DIAGRAM_PATH = DIAGRAMS.cli;
+// Parse command-line arguments
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const options = {
+        injectContent: false,
+        priorityFilter: '',
+        typeFilter: '',
+        includeDeprecated: false,
+        skipValidation: false,
+        diagram: 'cli',
+    };
+    for (let i = 0; i < args.length; i++) {
+        switch (args[i]) {
+            case '--inject-content':
+                options.injectContent = true;
+                break;
+            case '--priority':
+                options.priorityFilter = args[++i] || '';
+                break;
+            case '--type':
+                options.typeFilter = args[++i] || '';
+                break;
+            case '--include-deprecated':
+                options.includeDeprecated = true;
+                break;
+            case '--skip-validation':
+                options.skipValidation = true;
+                break;
+            case '--diagram':
+                const diagramArg = args[++i] || 'cli';
+                if (diagramArg !== 'cli' && diagramArg !== 'docker') {
+                    console.error(`Invalid diagram type: ${diagramArg}. Use 'cli' or 'docker'`);
+                    process.exit(1);
+                }
+                options.diagram = diagramArg;
+                break;
+            case '--help':
+            case '-h':
+                printHelp();
+                process.exit(0);
+            default:
+                console.error(`Unknown option: ${args[i]}`);
+                printHelp();
+                process.exit(1);
+        }
+    }
+    // Set global diagram path based on option
+    DIAGRAM_PATH = DIAGRAMS[options.diagram];
+    return options;
+}
+function printHelp() {
+    console.log(`
+CFN Dependency Ingestion - TypeScript Implementation
+
+Usage:
+  node ingest-dependencies.js [options]
+
+Options:
+  --diagram cli|docker     Select dependency diagram (default: cli)
+  --inject-content         Inject file contents directly (default: output Read commands)
+  --priority P0,P1,P2     Filter by priority levels (comma-separated)
+  --type TS,SH            Filter by file type (TS=TypeScript, SH=Shell)
+  --include-deprecated    Include deprecated files
+  --skip-validation       Skip file existence validation
+  --help, -h             Show this help message
+
+Diagrams:
+  cli    - CFN_LOOP_DEPENDENCY_DIAGRAM.txt (CLI mode execution flow)
+  docker - CFN_LOOP_DOCKER_DEPENDENCY_DIAGRAM.txt (Docker mode execution flow)
+
+Examples:
+  # CLI mode dependencies (default)
+  node ingest-dependencies.js --inject-content
+
+  # Docker mode dependencies
+  node ingest-dependencies.js --diagram docker --inject-content
+
+  # P0 files only with content injection
+  node ingest-dependencies.js --inject-content --priority P0
+
+  # TypeScript files only
+  node ingest-dependencies.js --type TS
+`);
+}
+// Extract all file paths from the dependency diagram
+function extractAllFiles() {
+    const diagramContent = fs.readFileSync(DIAGRAM_PATH, 'utf-8');
+    const filePattern = /\.(claude|src|tests)\/[^ ,)]+\.(md|ts|sh|js|cjs)/g;
+    const matches = diagramContent.match(filePattern) || [];
+    // Deduplicate and filter wildcards
+    const uniqueFiles = [...new Set(matches)]
+        .filter(file => !file.includes('*') && !file.includes('<'));
+    return uniqueFiles;
+}
+// Validate file existence
+function validateFileExistence(files, skipValidation) {
+    if (skipValidation) {
+        return files;
+    }
+    const validFiles = [];
+    let missingCount = 0;
+    for (const file of files) {
+        // Handle both absolute and relative paths
+        const fullPath = path.isAbsolute(file)
+            ? file
+            : path.join(PROJECT_ROOT, file);
+        if (fs.existsSync(fullPath)) {
+            validFiles.push(file);
+        }
+        else {
+            console.error(`WARNING: File not found: ${file}`);
+            missingCount++;
+        }
+    }
+    if (missingCount > 0) {
+        console.error(`WARNING: ${missingCount} file(s) not found (use --skip-validation to disable checks)`);
+    }
+    return validFiles;
+}
+// Filter by priority markers
+function filterByPriority(files, priorityFilter) {
+    if (!priorityFilter) {
+        return files;
+    }
+    const diagramContent = fs.readFileSync(DIAGRAM_PATH, 'utf-8');
+    const priorities = priorityFilter.split(',');
+    return files.filter(file => {
+        const filename = path.basename(file);
+        return priorities.some(priority => {
+            const pattern = new RegExp(`\\[${priority}\\].*${filename}`);
+            return pattern.test(diagramContent);
+        });
+    });
+}
+// Filter by file type
+function filterByType(files, typeFilter) {
+    if (!typeFilter) {
+        return files;
+    }
+    return files.filter(file => {
+        const types = typeFilter.split(',');
+        return types.some(type => {
+            if (type === 'TS') {
+                return /\.(ts|js|cjs)$/.test(file);
+            }
+            else if (type === 'SH') {
+                return /\.sh$/.test(file);
+            }
+            return false;
+        });
+    });
+}
+// Filter deprecated files
+function filterDeprecated(files, includeDeprecated) {
+    if (includeDeprecated) {
+        return files;
+    }
+    const diagramContent = fs.readFileSync(DIAGRAM_PATH, 'utf-8');
+    return files.filter(file => {
+        const filename = path.basename(file);
+        const deprecatedPattern = new RegExp(`\\[DEPRECATED\\].*${filename}`);
+        // Exclude if marked DEPRECATED
+        if (deprecatedPattern.test(diagramContent)) {
+            return false;
+        }
+        // Exclude helpers unless marked with priority
+        if (file.includes('/helpers/')) {
+            const priorityPattern = new RegExp(`\\[(P0|P1|P2)\\].*${filename}`);
+            return priorityPattern.test(diagramContent);
+        }
+        return true;
+    });
+}
+// Categorize files by priority
+function categorizeByPriority(files, diagramType) {
+    const diagramContent = fs.readFileSync(DIAGRAM_PATH, 'utf-8');
+    const diagramFile = diagramType === 'docker'
+        ? 'readme/CFN_LOOP_DOCKER_DEPENDENCY_DIAGRAM.txt'
+        : 'readme/CFN_LOOP_DEPENDENCY_DIAGRAM.txt';
+    const categories = {
+        diagram: [diagramFile],
+        P0: [],
+        P1: [],
+        P2: [],
+        coordination: [],
+        agents: [],
+        commands: [],
+    };
+    for (const file of files) {
+        const filename = path.basename(file);
+        if (/\[P0\]/.test(diagramContent) && new RegExp(`\\[P0\\].*${filename}`).test(diagramContent)) {
+            categories.P0.push(file);
+        }
+        else if (/\[P1\]/.test(diagramContent) && new RegExp(`\\[P1\\].*${filename}`).test(diagramContent)) {
+            categories.P1.push(file);
+        }
+        else if (/\[P2\]/.test(diagramContent) && new RegExp(`\\[P2\\].*${filename}`).test(diagramContent)) {
+            categories.P2.push(file);
+        }
+        else if (/coordination-wait|report-completion|orchestrate|cfn-redis/.test(file)) {
+            categories.coordination.push(file);
+        }
+        else if (file.includes('.claude/agents/cfn-dev-team')) {
+            categories.agents.push(file);
+        }
+        else if (file.includes('.claude/commands')) {
+            categories.commands.push(file);
+        }
+    }
+    return categories;
+}
+// Estimate token count
+function estimateTokens(text) {
+    return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+// Read file content with error handling
+function readFileContent(filePath) {
+    try {
+        // Handle both absolute and relative paths
+        const fullPath = path.isAbsolute(filePath)
+            ? filePath
+            : path.join(PROJECT_ROOT, filePath);
+        return fs.readFileSync(fullPath, 'utf-8');
+    }
+    catch (error) {
+        return `[ERROR: Could not read file: ${error}]`;
+    }
+}
+// Split content into chunks for parallel reading
+function splitIntoChunks(files) {
+    // Ensure temp directory exists
+    if (!fs.existsSync(TEMP_DIR)) {
+        fs.mkdirSync(TEMP_DIR, { recursive: true });
+    }
+    // Clean old chunks
+    const oldChunks = fs.readdirSync(TEMP_DIR).filter(f => f.startsWith('chunk-'));
+    oldChunks.forEach(f => fs.unlinkSync(path.join(TEMP_DIR, f)));
+    let currentChunk = '';
+    let currentChunkTokens = 0;
+    let chunkIndex = 1;
+    const chunkFiles = [];
+    let totalTokens = 0;
+    for (const file of files) {
+        const content = readFileContent(file);
+        const fileBlock = `
+${'='.repeat(80)}
+FILE: ${file}
+${'='.repeat(80)}
+
+${content}
+
+`;
+        const blockTokens = estimateTokens(fileBlock);
+        // If adding this file exceeds chunk size, write current chunk
+        if (currentChunkTokens + blockTokens > CHUNK_SIZE && currentChunk.length > 0) {
+            const chunkPath = path.join(TEMP_DIR, `chunk-${chunkIndex}.txt`);
+            fs.writeFileSync(chunkPath, currentChunk, 'utf-8');
+            chunkFiles.push(chunkPath);
+            currentChunk = '';
+            currentChunkTokens = 0;
+            chunkIndex++;
+        }
+        currentChunk += fileBlock;
+        currentChunkTokens += blockTokens;
+        totalTokens += blockTokens;
+    }
+    // Write final chunk if any content remains
+    if (currentChunk.length > 0) {
+        const chunkPath = path.join(TEMP_DIR, `chunk-${chunkIndex}.txt`);
+        fs.writeFileSync(chunkPath, currentChunk, 'utf-8');
+        chunkFiles.push(chunkPath);
+    }
+    return { chunkFiles, totalTokens };
+}
+// Inject content mode - read all files and concatenate
+function injectContent(files) {
+    let totalContent = '';
+    let totalChars = 0;
+    const processedFiles = [];
+    // Build content with file markers
+    for (const file of files) {
+        const content = readFileContent(file);
+        const fileBlock = `
+${'='.repeat(80)}
+FILE: ${file}
+${'='.repeat(80)}
+
+${content}
+
+`;
+        totalContent += fileBlock;
+        totalChars += fileBlock.length;
+        processedFiles.push(file);
+    }
+    const totalTokens = estimateTokens(totalContent);
+    const exceeded25kLimit = totalTokens > TOKEN_LIMIT;
+    if (exceeded25kLimit) {
+        console.error(`WARNING: Content exceeds 25k token limit (${totalTokens} tokens)`);
+        console.error('Splitting into 20k token chunks for parallel reading...');
+        const { chunkFiles, totalTokens: chunkedTokens } = splitIntoChunks(files);
+        console.log('');
+        console.log('# CFN Loop CLI Dependency Context (Chunked)');
+        console.log(`# Total tokens: ${chunkedTokens.toLocaleString()}`);
+        console.log(`# Chunks: ${chunkFiles.length} files (20k tokens each)`);
+        console.log(`# Location: ${TEMP_DIR}/`);
+        console.log('');
+        console.log('# For Task tool agents: Read these files in parallel');
+        chunkFiles.forEach((chunkFile, idx) => {
+            console.log(`Read: ${chunkFile}`);
+        });
+        console.log('');
+        console.log('# Cleanup after reading: rm -rf /tmp/cfn-dependency-chunks/');
+        return {
+            files: processedFiles,
+            totalTokens: chunkedTokens,
+            exceeded25kLimit: true,
+        };
+    }
+    return {
+        files: processedFiles,
+        totalTokens,
+        content: totalContent,
+        exceeded25kLimit: false,
+    };
+}
+// Output Read commands (traditional mode)
+function outputReadCommands(categories, diagramType) {
+    const seenFiles = new Set();
+    const modeName = diagramType === 'docker' ? 'Docker' : 'CLI';
+    const diagramFile = categories.diagram[0];
+    const outputFile = (file) => {
+        if (!seenFiles.has(file)) {
+            seenFiles.add(file);
+            console.log(`Read: ${file}`);
+        }
+    };
+    console.log(`# CFN Loop ${modeName} Dependency Ingestion`);
+    console.log(`# Generated from: ${diagramFile}`);
+    console.log('');
+    console.log('# Step 1: Read the dependency diagram');
+    categories.diagram.forEach(outputFile);
+    console.log('');
+    console.log('# Step 2: Read P0 critical path files (required for 5-iteration e2e)');
+    if (categories.P0.length > 0) {
+        categories.P0.forEach(outputFile);
+    }
+    else {
+        console.log('# No P0 files found matching filters');
+    }
+    console.log('');
+    console.log('# Step 3: Read P1 files (post-validation features)');
+    if (categories.P1.length > 0) {
+        categories.P1.forEach(outputFile);
+    }
+    else {
+        console.log('# No P1 files found matching filters');
+    }
+    console.log('');
+    console.log('# Step 4: Read P2 files (deferred features)');
+    if (categories.P2.length > 0) {
+        categories.P2.forEach(outputFile);
+    }
+    else {
+        console.log('# No P2 files found matching filters');
+    }
+    console.log('');
+    console.log('# Step 5: Read coordination layer (Redis/Shell scripts)');
+    if (categories.coordination.length > 0) {
+        categories.coordination.forEach(outputFile);
+    }
+    else {
+        console.log('# No coordination files found matching filters');
+    }
+    console.log('');
+    console.log('# Step 6: Read agent profiles (coordinators and workers)');
+    if (categories.agents.length > 0) {
+        categories.agents.forEach(outputFile);
+    }
+    else {
+        console.log('# No agent profile files found');
+    }
+    console.log('');
+    console.log('# Step 7: Read slash commands');
+    if (categories.commands.length > 0) {
+        categories.commands.forEach(outputFile);
+    }
+    else {
+        console.log('# No command files found');
+    }
+    console.log('');
+    console.log('# Ingestion complete');
+    console.log(`# Total files: ${seenFiles.size}`);
+}
+// Main execution
+function main() {
+    const options = parseArgs();
+    // Validate diagram exists
+    if (!fs.existsSync(DIAGRAM_PATH)) {
+        console.error(`ERROR: Dependency diagram not found: ${DIAGRAM_PATH}`);
+        process.exit(1);
+    }
+    const modeName = options.diagram === 'docker' ? 'Docker' : 'CLI';
+    const diagramFile = options.diagram === 'docker'
+        ? 'readme/CFN_LOOP_DOCKER_DEPENDENCY_DIAGRAM.txt'
+        : 'readme/CFN_LOOP_DEPENDENCY_DIAGRAM.txt';
+    // Extract and filter files
+    let files = extractAllFiles();
+    files = validateFileExistence(files, options.skipValidation);
+    files = filterByPriority(files, options.priorityFilter);
+    files = filterByType(files, options.typeFilter);
+    files = filterDeprecated(files, options.includeDeprecated);
+    // Add diagram to file list
+    const allFiles = [diagramFile, ...files];
+    if (options.injectContent) {
+        // Content injection mode
+        const result = injectContent(allFiles);
+        if (result.exceeded25kLimit) {
+            // Fallback to Read commands
+            const categories = categorizeByPriority(files, options.diagram);
+            outputReadCommands(categories, options.diagram);
+        }
+        else {
+            // Output injected content
+            console.log(`# CFN Loop ${modeName} Dependency Context`);
+            console.log(`# Files: ${result.files.length}`);
+            console.log(`# Estimated tokens: ${result.totalTokens.toLocaleString()}`);
+            console.log(`# Token limit: ${TOKEN_LIMIT.toLocaleString()}`);
+            console.log('');
+            console.log(result.content);
+        }
+    }
+    else {
+        // Traditional Read command mode
+        const categories = categorizeByPriority(files, options.diagram);
+        outputReadCommands(categories, options.diagram);
+    }
+}
+// Execute if run directly (ESM compatible)
+const __filename = fileURLToPath(import.meta.url);
+const isMainModule = process.argv[1] === __filename;
+if (isMainModule) {
+    main();
+}
+export { extractAllFiles, filterByPriority, filterByType, injectContent, estimateTokens };