codereview-aia 0.1.3 → 0.1.4

package/src/utils/templateLoader.ts

@@ -1,514 +0,0 @@
-/**
- * Template Loader Utility
- *
- * This utility loads and compiles Handlebars templates from the promptText directory.
- * It supports variable substitution, partials, and conditional logic.
- */
-
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as Handlebars from 'handlebars';
-import { configurationService } from '../core/ConfigurationService';
-import logger from './logger';
-import { resolvePromptTemplatesDir } from './promptPaths';
-
-// Get the templates directory from configuration or use a fallback
-const getTemplatesDir = (): string => {
-  try {
-    // Use the configured path from ConfigurationService
-    const configuredPath = configurationService.getPathsConfig().promptsDir;
-    if (configuredPath && fs.existsSync(configuredPath)) {
-      logger.debug(`Using configured templates directory: ${configuredPath}`);
-      return configuredPath;
-    }
-
-    // Fallback to default
-    const defaultPath = resolvePromptTemplatesDir();
-    logger.debug(`Using default templates directory: ${defaultPath}`);
-    return defaultPath;
-  } catch (error) {
-    // If there's any error with the configuration, use default
-    logger.warn(
-      `Error getting templates directory from config: ${error instanceof Error ? error.message : String(error)}`,
-    );
-    const fallbackPath = resolvePromptTemplatesDir();
-    logger.debug(`Using fallback templates directory: ${fallbackPath}`);
-    return fallbackPath;
-  }
-};
-
-// Interface for framework version information
-interface FrameworkVersion {
-  version: string;
-  releaseDate: string;
-  supportedUntil: string;
-  features: string[];
-  [key: string]: unknown;
-}
-
-// Interface for framework information
-interface Framework {
-  latest: FrameworkVersion;
-  previous: FrameworkVersion;
-  [key: string]: unknown;
-}
-
-// Interface for framework data
-interface FrameworkData {
-  frameworks: {
-    [key: string]: Framework;
-  };
-}
-
-// Interface for CSS framework data
-interface CssFrameworkData {
-  cssFrameworks: {
-    [key: string]: {
-      name: string;
-      version: string;
-      releaseDate: string;
-      features: string[];
-      integrations: {
-        [key: string]: string;
-      };
-    };
-  };
-}
-
-/**
- * Template cache to avoid re-reading and re-compiling templates
- */
-const templateCache: Record<string, HandlebarsTemplateDelegate> = {};
-
-/**
- * Register helpers and partials for Handlebars
- */
-function initializeHandlebars(): void {
-  // Register comparison helper
-  Handlebars.registerHelper(
-    'eq',
-    function (this: unknown, arg1: unknown, arg2: unknown, options: Handlebars.HelperOptions) {
-      return arg1 === arg2 ? options.fn(this) : options.inverse(this);
-    },
-  );
-
-  // Register join helper for arrays
-  Handlebars.registerHelper('join', (array: unknown, separator: string) => {
-    if (Array.isArray(array)) {
-      return array.join(separator);
-    }
-    return '';
-  });
-
-  // Register partials by scanning the common directory
-  const partialsDir = path.join(getTemplatesDir(), 'common');
-  registerPartials(partialsDir, '');
-}
-
-/**
- * Recursively register partials from a directory
- *
- * @param dirPath Directory path to scan for partials
- * @param prefix Prefix for partial names (based on directory hierarchy)
- */
-function registerPartials(dirPath: string, prefix: string): void {
-  try {
-    // Check if directory exists
-    if (!fs.existsSync(dirPath)) {
-      logger.warn(`Partials directory not found: ${dirPath}`);
-      return;
-    }
-
-    // Read directory entries
-    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
-
-    for (const entry of entries) {
-      const fullPath = path.join(dirPath, entry.name);
-
-      if (entry.isDirectory()) {
-        // Recurse into subdirectories
-        registerPartials(fullPath, `${prefix}${entry.name}/`);
-      } else if (entry.name.endsWith('.hbs')) {
-        try {
-          // Register .hbs files as partials
-          const partialName = `${prefix}${entry.name.replace('.hbs', '')}`;
-          const partialContent = fs.readFileSync(fullPath, 'utf-8');
-          Handlebars.registerPartial(`common/${partialName}`, partialContent);
-          logger.debug(`Registered partial: common/${partialName}`);
-        } catch (partialError) {
-          // Handle errors for individual partial files
-          logger.error(
-            `Error registering partial ${fullPath}: ${
-              partialError instanceof Error ? partialError.message : String(partialError)
-            }`,
-          );
-          // Continue with other partials even if one fails
-        }
-      }
-    }
-  } catch (error) {
-    // Handle directory reading errors
-    logger.error(
-      `Error scanning partials directory ${dirPath}: ${
-        error instanceof Error ? error.message : String(error)
-      }`,
-    );
-    // Return so calling code knows registration may be incomplete
-  }
-}
-
-/**
- * Load template variables from JSON files
- *
- * @returns Combined variables object for template rendering
- */
-function loadTemplateVariables(): Record<string, unknown> {
-  const variables: Record<string, unknown> = {};
-
-  try {
-    // Check if variables directory exists
-    const variablesDir = path.join(getTemplatesDir(), 'common', 'variables');
-    if (!fs.existsSync(variablesDir)) {
-      logger.warn(`Variables directory not found: ${variablesDir}`);
-      return variables;
-    }
-
-    // Load framework versions data
-    const frameworksPath = path.join(variablesDir, 'framework-versions.json');
-    if (fs.existsSync(frameworksPath)) {
-      try {
-        const fileContents = fs.readFileSync(frameworksPath, 'utf-8');
-        const frameworkData = JSON.parse(fileContents) as FrameworkData;
-        variables.frameworks = frameworkData.frameworks;
-        logger.debug('Successfully loaded framework versions data');
-      } catch (readError) {
-        logger.error(
-          `Error reading or parsing framework versions data: ${
-            readError instanceof Error ? readError.message : String(readError)
-          }`,
-        );
-        // Provide empty frameworks object instead of leaving it undefined
-        variables.frameworks = {};
-      }
-    } else {
-      logger.debug(`Framework versions file not found: ${frameworksPath}`);
-      variables.frameworks = {};
-    }
-
-    // Load CSS frameworks data
-    const cssFrameworksPath = path.join(variablesDir, 'css-frameworks.json');
-    if (fs.existsSync(cssFrameworksPath)) {
-      try {
-        const fileContents = fs.readFileSync(cssFrameworksPath, 'utf-8');
-        const cssFrameworkData = JSON.parse(fileContents) as CssFrameworkData;
-        variables.cssFrameworks = cssFrameworkData.cssFrameworks;
-        logger.debug('Successfully loaded CSS frameworks data');
-      } catch (readError) {
-        logger.error(
-          `Error reading or parsing CSS frameworks data: ${
-            readError instanceof Error ? readError.message : String(readError)
-          }`,
-        );
-        // Provide empty cssFrameworks object instead of leaving it undefined
-        variables.cssFrameworks = {};
-      }
-    } else {
-      logger.debug(`CSS frameworks file not found: ${cssFrameworksPath}`);
-      variables.cssFrameworks = {};
-    }
-
-    // Scan the variables directory for other JSON files and load them
-    try {
-      const entries = fs.readdirSync(variablesDir);
-      const otherJsonFiles = entries.filter(
-        (entry) =>
-          entry.endsWith('.json') &&
-          entry !== 'framework-versions.json' &&
-          entry !== 'css-frameworks.json',
-      );
-
-      for (const jsonFile of otherJsonFiles) {
-        try {
-          const filePath = path.join(variablesDir, jsonFile);
-          const fileContents = fs.readFileSync(filePath, 'utf-8');
-          const data = JSON.parse(fileContents);
-
-          // Use the filename without extension as the variable key
-          const key = jsonFile.replace('.json', '');
-          variables[key] = data;
-          logger.debug(`Loaded additional variable file: ${jsonFile}`);
-        } catch (fileError) {
-          logger.error(
-            `Error reading or parsing ${jsonFile}: ${
-              fileError instanceof Error ? fileError.message : String(fileError)
-            }`,
-          );
-        }
-      }
-    } catch (scanError) {
-      logger.error(
-        `Error scanning variables directory for additional JSON files: ${
-          scanError instanceof Error ? scanError.message : String(scanError)
-        }`,
-      );
-    }
-  } catch (error) {
-    // Catch any unexpected errors
-    logger.error(
-      `Unexpected error loading template variables: ${
-        error instanceof Error ? error.message : String(error)
-      }`,
-    );
-  }
-
-  return variables;
-}
-
-/**
- * Load and compile a template from the given path
- *
- * @param templatePath Path to the template file (relative to TEMPLATES_DIR)
- * @returns Compiled Handlebars template function
- */
-function loadTemplate(templatePath: string): HandlebarsTemplateDelegate | null {
-  // Check cache first
-  if (templateCache[templatePath]) {
-    return templateCache[templatePath];
-  }
-
-  const fullPath = path.join(getTemplatesDir(), templatePath);
-
-  // Check if template exists
-  if (!fs.existsSync(fullPath)) {
-    logger.error(`Template not found: ${fullPath}`);
-    return null;
-  }
-
-  try {
-    // Read and compile template
-    const templateContent = fs.readFileSync(fullPath, 'utf-8');
-    const template = Handlebars.compile(templateContent);
-
-    // Cache compiled template
-    templateCache[templatePath] = template;
-
-    return template;
-  } catch (error) {
-    logger.error(`Error loading template ${fullPath}: ${error}`);
-    return null;
-  }
-}
-
-/**
- * Render a template with provided variables
- *
- * @param templatePath Path to the template file (relative to TEMPLATES_DIR)
- * @param customVars Optional custom variables to merge with default variables
- * @returns Rendered template string or null if rendering fails
- */
-export function renderTemplate(
-  templatePath: string,
-  customVars: Record<string, unknown> = {},
-): string | null {
-  // Initialize Handlebars if not already initialized
-  if (Object.keys(Handlebars.partials).length === 0) {
-    initializeHandlebars();
-  }
-
-  // Load template
-  const template = loadTemplate(templatePath);
-  if (!template) {
-    return null;
-  }
-
-  // Load variables and merge with custom vars
-  const defaultVars = loadTemplateVariables();
-  const variables = { ...defaultVars, ...customVars };
-
-  try {
-    // Render template with variables
-    return template(variables);
-  } catch (error) {
-    logger.error(`Error rendering template ${templatePath}: ${error}`);
-    return null;
-  }
-}
-
-/**
- * Load a template for a specific framework or language
- *
- * @param reviewType Type of review (e.g., 'best-practices', 'security')
- * @param language Language (e.g., 'typescript', 'python')
- * @param framework Optional framework (e.g., 'react', 'angular')
- * @returns Rendered template string or null if not found
- */
-export function loadPromptTemplate(
-  reviewType: string,
-  language?: string,
-  framework?: string,
-): string | null {
-  // Try framework-specific template first
-  if (language && framework) {
-    const frameworkPath = `frameworks/${framework}/${reviewType}.hbs`;
-    const rendered = renderTemplate(frameworkPath);
-    if (rendered) {
-      logger.debug(`Loaded framework-specific template: ${frameworkPath}`);
-      return rendered;
-    }
-  }
-
-  // Try language-specific template
-  if (language) {
-    const languagePath = `languages/${language}/${reviewType}.hbs`;
-    const rendered = renderTemplate(languagePath);
-    if (rendered) {
-      logger.debug(`Loaded language-specific template: ${languagePath}`);
-      return rendered;
-    }
-  }
-
-  // Fall back to generic template
-  const genericPath = `languages/generic/${reviewType}.hbs`;
-  const rendered = renderTemplate(genericPath);
-  if (rendered) {
-    logger.debug(`Loaded generic template: ${genericPath}`);
-    return rendered;
-  }
-
-  logger.error(
-    `No template found for reviewType=${reviewType}, language=${language ?? 'undefined'}, framework=${framework ?? 'undefined'}`,
-  );
-  return null;
-}
-
-/**
- * List all available templates
- *
- * @returns Map of available templates by category
- */
-export function listAvailableTemplates(): Record<string, string[]> {
-  const result: Record<string, string[]> = {
-    frameworks: [],
-    languages: [],
-    reviewTypes: [],
-  };
-
-  try {
-    // Scan frameworks directory
-    const frameworksDir = path.join(getTemplatesDir(), 'frameworks');
-    if (fs.existsSync(frameworksDir)) {
-      try {
-        const entries = fs.readdirSync(frameworksDir, { withFileTypes: true });
-        result.frameworks = entries
-          .filter((entry) => entry.isDirectory())
-          .map((entry) => entry.name);
-      } catch (error) {
-        logger.error(
-          `Error reading frameworks directory ${frameworksDir}: ${
-            error instanceof Error ? error.message : String(error)
-          }`,
-        );
-      }
-    } else {
-      logger.debug(`Frameworks directory not found: ${frameworksDir}`);
-    }
-
-    // Scan languages directory
-    const languagesDir = path.join(getTemplatesDir(), 'languages');
-    if (fs.existsSync(languagesDir)) {
-      try {
-        const entries = fs.readdirSync(languagesDir, { withFileTypes: true });
-        result.languages = entries
-          .filter((entry) => entry.isDirectory())
-          .map((entry) => entry.name);
-      } catch (error) {
-        logger.error(
-          `Error reading languages directory ${languagesDir}: ${
-            error instanceof Error ? error.message : String(error)
-          }`,
-        );
-      }
-    } else {
-      logger.debug(`Languages directory not found: ${languagesDir}`);
-    }
-
-    // Get review types from any framework (assuming all frameworks have the same review types)
-    // or from the generic directory if no frameworks are available
-    if (Array.isArray(result.frameworks) && result.frameworks.length > 0) {
-      try {
-        const firstFramework = result.frameworks[0];
-        if (firstFramework) {
-          const firstFrameworkDir = path.join(frameworksDir, firstFramework);
-          if (fs.existsSync(firstFrameworkDir)) {
-            const entries = fs.readdirSync(firstFrameworkDir);
-            result.reviewTypes = entries
-              .filter((entry) => entry.endsWith('.hbs'))
-              .map((entry) => entry.replace('.hbs', ''));
-          }
-        }
-      } catch (error) {
-        logger.error(
-          `Error reading review types from framework directory: ${
-            error instanceof Error ? error.message : String(error)
-          }`,
-        );
-      }
-    }
-
-    // If we couldn't get review types from frameworks, try the generic directory
-    if (!Array.isArray(result.reviewTypes) || result.reviewTypes.length === 0) {
-      try {
-        const genericDir = path.join(languagesDir, 'generic');
-        if (fs.existsSync(genericDir)) {
-          const entries = fs.readdirSync(genericDir);
-          result.reviewTypes = entries
-            .filter((entry) => entry.endsWith('.hbs'))
-            .map((entry) => entry.replace('.hbs', ''));
-        }
-      } catch (error) {
-        logger.error(
-          `Error reading review types from generic directory: ${
-            error instanceof Error ? error.message : String(error)
-          }`,
-        );
-      }
-    }
-  } catch (error) {
-    // Catch any other unexpected errors
-    logger.error(
-      `Unexpected error listing available templates: ${
-        error instanceof Error ? error.message : String(error)
-      }`,
-    );
-  }
-
-  return result;
-}
-
-/**
- * Clear the template cache to force reloading of templates
- * This is useful when the configuration changes
- */
-export function clearTemplateCache(): void {
-  // Reset cache and Handlebars registrations
-  for (const key in templateCache) {
-    delete templateCache[key];
-  }
-
-  // Clear registered partials
-  for (const key in Handlebars.partials) {
-    Handlebars.unregisterPartial(key);
-  }
-
-  logger.debug('Template cache cleared');
-}
-
-/**
- * Export loadPromptTemplate as default
- */
-export default {
-  renderTemplate,
-  loadPromptTemplate,
-  listAvailableTemplates,
-  clearTemplateCache,
-};

package/src/utils/treeGenerator.ts

@@ -1,153 +0,0 @@
-/**
- * @fileoverview Utility to generate tree structure from file paths
- *
- * This module provides functions to convert a list of file paths into a
- * hierarchical tree structure for display in a markdown file.
- */
-
-// import path from 'path'; // Not used in this file
-import logger from './logger';
-
-/**
- * Node in the file tree structure
- */
-interface TreeNode {
-  name: string;
-  children: Map<string, TreeNode>;
-  isFile: boolean;
-  path?: string;
-}
-
-/**
- * Create a new tree node
- * @param name Name of the node
- * @param isFile Whether this node represents a file
- * @param filePath Full path of the file (for files only)
- * @returns A new tree node
- */
-function createNode(name: string, isFile = false, filePath?: string): TreeNode {
-  return {
-    name,
-    children: new Map<string, TreeNode>(),
-    isFile,
-    path: filePath,
-  };
-}
-
-/**
- * Build a tree structure from a list of file paths
- * @param filePaths Array of file paths (relative or absolute)
- * @returns Root node of the tree
- */
-function buildTree(filePaths: string[]): TreeNode {
-  // Create the root node
-  const root: TreeNode = createNode('root');
-
-  // Add each file to the tree
-  for (const filePath of filePaths) {
-    // Split the path into components
-    const parts = filePath.split(/[\\/]/);
-
-    // Start at the root
-    let currentNode = root;
-
-    // Traverse the path components
-    for (let i = 0; i < parts.length; i++) {
-      const part = parts[i];
-      if (!part) continue; // Skip empty parts
-
-      const isFile = i === parts.length - 1;
-
-      // If this node doesn't exist yet, create it
-      if (!currentNode.children.has(part)) {
-        currentNode.children.set(part, createNode(part, isFile, isFile ? filePath : undefined));
-      } else if (isFile) {
-        // If it exists but is a directory and we're adding a file with the same name
-        const existingNode = currentNode.children.get(part)!;
-        if (!existingNode.isFile) {
-          // This is a special case where a directory has the same name as a file
-          // Create a special file node with a unique name
-          currentNode.children.set(`${part} (file)`, createNode(part, true, filePath));
-          continue;
-        }
-      }
-
-      // Move to the next node
-      currentNode = currentNode.children.get(part)!;
-    }
-  }
-
-  return root;
-}
-
-/**
- * Generate a markdown representation of the tree
- * @param node The current tree node
- * @param indent Current indentation level
- * @param isLast Whether this is the last child of its parent
- * @param prefix Prefix for the current line
- * @returns Markdown string representing the tree
- */
-function generateMarkdownTree(node: TreeNode, indent = '', isLast = true, prefix = ''): string {
-  if (node.name === 'root') {
-    // Root node is special - process its children directly
-    let result = '';
-    const children = Array.from(node.children.entries());
-
-    for (let i = 0; i < children.length; i++) {
-      const [, childNode] = children[i];
-      const isLastChild = i === children.length - 1;
-      result += generateMarkdownTree(childNode, '', isLastChild, '');
-    }
-
-    return result;
-  }
-
-  // Current node indicator
-  const nodeIndicator = isLast ? '└── ' : '├── ';
-
-  // Generate this node's line
-  let result = `${indent}${prefix}${nodeIndicator}${node.name}\n`;
-
-  // Generate child node prefix
-  const childPrefix = isLast ? '    ' : '│   ';
-
-  // Process children
-  const children = Array.from(node.children.entries()).sort(([nameA], [nameB]) => {
-    // Directories first, then files
-    const nodeA = node.children.get(nameA)!;
-    const nodeB = node.children.get(nameB)!;
-    if (nodeA.isFile && !nodeB.isFile) return 1;
-    if (!nodeA.isFile && nodeB.isFile) return -1;
-    return nameA.localeCompare(nameB);
-  });
-
-  for (let i = 0; i < children.length; i++) {
-    const [, childNode] = children[i];
-    const isLastChild = i === children.length - 1;
-    result += generateMarkdownTree(childNode, `${indent}${prefix}${childPrefix}`, isLastChild, '');
-  }
-
-  return result;
-}
-
-/**
- * Generate a markdown tree representation of file paths
- * @param filePaths Array of file paths
- * @returns Markdown string representing the tree structure
- */
-export function generateFileTree(filePaths: string[]): string {
-  try {
-    // Sort file paths to ensure consistent output
-    const sortedPaths = [...filePaths].sort();
-
-    // Build the tree structure
-    const root = buildTree(sortedPaths);
-
-    // Generate the markdown
-    return `\`\`\`\n${generateMarkdownTree(root)}\`\`\``;
-  } catch (error) {
-    logger.error(`Error generating file tree: ${error}`);
-    return filePaths.map((file) => `- \`${file}\``).join('\n');
-  }
-}

package/tsconfig.build.json

@@ -1,14 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "declaration": true,
-    "emitDeclarationOnly": true
-  },
-  "exclude": [
-    "node_modules", 
-    "dist", 
-    "**/*.test.ts", 
-    "test-projects/**/*", 
-    "**/examples/**/*"
-  ]
-}