@skmtc/core 0.0.924 → 0.0.926

package/script/helpers/generationStats.js

@@ -1,339 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkResult = exports.toManifestErrors = exports.toTotalTime = exports.toManifestLines = exports.toManifestTokens = exports.toGenerationStats = void 0;
-require("../_dnt.polyfills.js");
-const ts_pattern_1 = require("ts-pattern");
-const gpt_tokenizer_1 = require("gpt-tokenizer");
-/**
- * Generates comprehensive statistics about the code generation process.
- *
- * This function analyzes the generation manifest and produced artifacts to create
- * detailed statistics including token counts, lines of code, timing information,
- * error tracking, and file counts. It's used for performance monitoring, debugging,
- * and reporting on generation runs.
- *
- * The function combines multiple analysis methods to provide a complete picture
- * of the generation process, including tokenization analysis for cost estimation,
- * error path extraction for debugging, and timing analysis for performance optimization.
- *
- * @param args - Generation analysis configuration
- * @param args.manifest - The generation manifest with metadata and results
- * @param args.artifacts - Map of file paths to generated content
- * @returns Comprehensive generation statistics object
- *
- * @example Basic usage
- * ```typescript
- * import { toGenerationStats } from '@skmtc/core';
- *
- * const stats = toGenerationStats({
- *   manifest: {
- *     startAt: 1672531200000,
- *     endAt: 1672531245000,
- *     files: {
- *       './models.ts': { lines: 150, characters: 4500 },
- *       './types.ts': { lines: 80, characters: 2100 }
- *     },
- *     results: { }
- *   },
- *   artifacts: {
- *     './models.ts': 'export interface User { id: string; name: string; }',
- *     './types.ts': 'export type Status = "active" | "inactive";'
- *   }
- * });
- *
- * console.log(stats);
- * // {
- * //   tokens: 250,
- * //   lines: 230,
- * //   totalTime: 45000,
- * //   errors: [],
- * //   files: 2
- * // }
- * ```
- *
- * @example Performance monitoring
- * ```typescript
- * class GenerationMonitor {
- *   analyzeGeneration(manifest: ManifestContent, artifacts: Record<string, string>) {
- *     const stats = toGenerationStats({ manifest, artifacts });
- *
- *     console.log(`Generation completed in ${stats.totalTime}ms`);
- *     console.log(`Generated ${stats.files} files with ${stats.lines} lines`);
- *     console.log(`Token usage: ${stats.tokens} tokens`);
- *
- *     if (stats.errors.length > 0) {
- *       console.warn(`Found ${stats.errors.length} errors:`);
- *       stats.errors.forEach((errorPath, index) => {
- *         console.warn(`  ${index + 1}. ${errorPath.join(' -> ')}`);
- *       });
- *     }
- *
- *     return stats;
- *   }
- * }
- * ```
- *
- * @example Cost estimation
- * ```typescript
- * function estimateGenerationCost(stats: GenerationStats): number {
- *   const tokensPerDollar = 1000000; // Example rate
- *   const estimatedCost = stats.tokens / tokensPerDollar;
- *
- *   console.log(`Estimated cost: $${estimatedCost.toFixed(4)}`);
- *   console.log(`Efficiency: ${stats.lines / stats.tokens} lines per token`);
- *
- *   return estimatedCost;
- * }
- * ```
- *
- * @example Build reporting
- * ```typescript
- * function generateBuildReport(stats: GenerationStats): string {
- *   const efficiency = stats.totalTime / stats.files;
- *   const successRate = ((stats.files - stats.errors.length) / stats.files * 100).toFixed(1);
- *
- *   return `
- * Build Report:
- * -----------
- * Files Generated: ${stats.files}
- * Total Lines: ${stats.lines.toLocaleString()}
- * Token Count: ${stats.tokens.toLocaleString()}
- * Generation Time: ${(stats.totalTime / 1000).toFixed(2)}s
- * Average per File: ${efficiency.toFixed(0)}ms
- * Success Rate: ${successRate}%
- * Errors: ${stats.errors.length}
- *   `.trim();
- * }
- * ```
- */
-const toGenerationStats = ({ manifest, artifacts }) => {
-    const tokens = (0, exports.toManifestTokens)(artifacts);
-    const lines = (0, exports.toManifestLines)(manifest);
-    const totalTime = (0, exports.toTotalTime)(manifest);
-    const errors = (0, exports.toManifestErrors)(manifest.results);
-    const files = Object.keys(artifacts).length;
-    return {
-        tokens,
-        lines,
-        totalTime,
-        errors,
-        files
-    };
-};
-exports.toGenerationStats = toGenerationStats;
-/**
- * Calculates the total number of GPT tokens in all generated artifacts.
- *
- * This function uses GPT tokenization to count the total number of tokens
- * across all generated code artifacts. This is useful for cost estimation
- * when using token-based pricing models and for understanding the size
- * and complexity of generated content.
- *
- * @param artifacts - Map of file paths to generated content strings
- * @returns Total number of GPT tokens across all artifacts
- *
- * @example
- * ```typescript
- * const artifacts = {
- *   './models.ts': 'export interface User { id: string; name: string; }',
- *   './types.ts': 'export type Status = "active" | "inactive";'
- * };
- *
- * const tokens = toManifestTokens(artifacts);
- * console.log(tokens); // e.g., 24 tokens
- * ```
- */
-const toManifestTokens = (artifacts) => {
-    const { tokens } = Object.values(artifacts).reduce((acc, artifact) => ({ tokens: acc.tokens + (0, gpt_tokenizer_1.countTokens)(artifact) }), { tokens: 0 });
-    return tokens;
-};
-exports.toManifestTokens = toManifestTokens;
-/**
- * Calculates the total number of lines across all generated files.
- *
- * This function sums up the line counts from the manifest's file metadata
- * to provide the total lines of code generated. This metric is useful
- * for understanding the scale of code generation and tracking productivity.
- *
- * @param manifest - The generation manifest containing file metadata
- * @returns Total number of lines across all generated files
- *
- * @example
- * ```typescript
- * const manifest = {
- *   files: {
- *     './models.ts': { lines: 150, characters: 4500 },
- *     './types.ts': { lines: 80, characters: 2100 }
- *   },
- *   // ... other manifest properties
- * };
- *
- * const lines = toManifestLines(manifest);
- * console.log(lines); // 230
- * ```
- */
-const toManifestLines = (manifest) => {
-    const { lines } = Object.values(manifest.files).reduce((acc, file) => ({ lines: acc.lines + file.lines }), { lines: 0 });
-    return lines;
-};
-exports.toManifestLines = toManifestLines;
-/**
- * Calculates the total generation time from the manifest timestamps.
- *
- * This function computes the duration of the generation process by
- * calculating the difference between the end and start timestamps
- * recorded in the manifest. The result is in milliseconds.
- *
- * @param manifest - The generation manifest with timing information
- * @returns Total generation time in milliseconds
- *
- * @example
- * ```typescript
- * const manifest = {
- *   startAt: 1672531200000, // January 1, 2023 00:00:00 GMT
- *   endAt: 1672531245000,   // January 1, 2023 00:00:45 GMT
- *   // ... other manifest properties
- * };
- *
- * const duration = toTotalTime(manifest);
- * console.log(duration); // 45000 (45 seconds)
- * console.log(`${duration / 1000}s`); // "45s"
- * ```
- */
-const toTotalTime = (manifest) => {
-    const totalTime = manifest.endAt - manifest.startAt;
-    return totalTime;
-};
-exports.toTotalTime = toTotalTime;
-/**
- * Extracts and organizes error paths from the manifest results.
- *
- * This function recursively traverses the results structure in the manifest
- * to identify all error conditions and their associated file paths. Errors
- * are returned as arrays of path segments, making it easy to understand
- * the location and context of each error.
- *
- * @param results - The results object from the generation manifest
- * @returns Array of error paths, each represented as an array of path segments
- *
- * @example
- * ```typescript
- * const results = {
- *   'models.ts': {
- *     'User': 'success',
- *     'Product': 'error'
- *   },
- *   'types.ts': 'success'
- * };
- *
- * const errors = toManifestErrors(results);
- * console.log(errors); // [['models.ts', 'Product']]
- *
- * // Display errors in readable format
- * errors.forEach(errorPath => {
- *   console.log(`Error at: ${errorPath.join(' -> ')}`);
- * });
- * // Output: "Error at: models.ts -> Product"
- * ```
- */
-const toManifestErrors = (results) => {
-    const errors = [];
-    Object.entries(results).map(([path, result]) => {
-        return (0, exports.checkResult)({ path: [path], result, errors });
-    });
-    return errors;
-};
-exports.toManifestErrors = toManifestErrors;
-/**
- * Recursively checks results structure for error conditions and collects error paths.
- *
- * This function traverses the complex nested structure of generation results,
- * identifying error conditions at any level and recording their full path context.
- * It handles arrays, objects, strings, and null values, building a comprehensive
- * map of all errors that occurred during generation.
- *
- * The function mutates the errors array parameter, accumulating error paths
- * as it traverses the results structure. This approach is used for performance
- * when processing large result sets.
- *
- * @param args - Arguments for result checking
- * @param args.path - Current path segments being traversed
- * @param args.result - The result value to check for errors
- * @param args.errors - Array to accumulate error paths (mutated by function)
- *
- * @example Simple error detection
- * ```typescript
- * const errors: string[][] = [];
- *
- * checkResult({
- *   path: ['models.ts'],
- *   result: 'error',
- *   errors
- * });
- *
- * console.log(errors); // [['models.ts']]
- * ```
- *
- * @example Nested structure error detection
- * ```typescript
- * const errors: string[][] = [];
- * const nestedResult = {
- *   'User': 'success',
- *   'Product': {
- *     'validation': 'error',
- *     'generation': 'success'
- *   }
- * };
- *
- * checkResult({
- *   path: ['models.ts'],
- *   result: nestedResult,
- *   errors
- * });
- *
- * console.log(errors); // [['models.ts', 'Product', 'validation']]
- * ```
- *
- * @example Array handling
- * ```typescript
- * const errors: string[][] = [];
- * const arrayResult = ['success', null, 'error', 'success'];
- *
- * checkResult({
- *   path: ['batch'],
- *   result: arrayResult,
- *   errors
- * });
- *
- * console.log(errors); // [['batch']] - for the 'error' item
- * ```
- */
-const checkResult = ({ path, result, errors }) => {
-    (0, ts_pattern_1.match)(result)
-        .with(ts_pattern_1.P.array(), matchedResult => {
-        return matchedResult.map(item => {
-            if (item !== null) {
-                (0, exports.checkResult)({ path, result: item, errors });
-            }
-        });
-    })
-        .with(ts_pattern_1.P.string, matchedResult => {
-        if (matchedResult === 'error') {
-            errors.push(path);
-        }
-    })
-        .with(ts_pattern_1.P.nullish, matchedResult => {
-        return (0, exports.checkResult)({ path, result: matchedResult, errors });
-    })
-        .otherwise(matched => {
-        if (typeof matched === 'object') {
-            return Object.entries(matched).map(([key, value]) => {
-                return (0, exports.checkResult)({ path: [...path, key], result: value, errors });
-            });
-        }
-        else {
-            throw new Error('Invalid result type');
-        }
-    });
-};
-exports.checkResult = checkResult;