codereview-aia 0.1.0

package/src/utils/pathValidator.ts

@@ -0,0 +1,98 @@
+/**
+ * @fileoverview Path validation utilities.
+ *
+ * This module provides utilities for validating file and directory paths,
+ * ensuring they are safe to use and exist on the file system.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Check if a path is within the current directory or its subdirectories
+ * @param targetPath Path to check
+ * @returns True if the path is within the current directory, false otherwise
+ */
+export function isPathWithinCwd(targetPath: string): boolean {
+  const resolvedPath = path.resolve(targetPath);
+  const resolvedCwd = path.resolve(process.cwd());
+
+  return resolvedPath.startsWith(resolvedCwd);
+}
+
+/**
+ * Check if a path exists
+ * @param targetPath Path to check
+ * @returns True if the path exists, false otherwise
+ */
+export function pathExists(targetPath: string): boolean {
+  try {
+    fs.accessSync(targetPath);
+    return true;
+  } catch (_error) {
+    return false;
+  }
+}
+
+/**
+ * Check if a path is a directory
+ * @param targetPath Path to check
+ * @returns True if the path is a directory, false otherwise
+ */
+export function isDirectory(targetPath: string): boolean {
+  try {
+    return fs.statSync(targetPath).isDirectory();
+  } catch (_error) {
+    return false;
+  }
+}
+
+/**
+ * Check if a path is a file
+ * @param targetPath Path to check
+ * @returns True if the path is a file, false otherwise
+ */
+export function isFile(targetPath: string): boolean {
+  try {
+    return fs.statSync(targetPath).isFile();
+  } catch (_error) {
+    return false;
+  }
+}
+
+/**
+ * Validate a target path for security and existence
+ * @param targetPath Path to validate
+ * @returns Object with validation results
+ */
+export function validateTargetPath(targetPath: string): {
+  isValid: boolean;
+  isDir: boolean;
+  error?: string;
+} {
+  // Check if the path is within the current directory
+  if (!isPathWithinCwd(targetPath)) {
+    return {
+      isValid: false,
+      isDir: false,
+      error: `Path must be within the current directory: ${process.cwd()}`,
+    };
+  }
+
+  // Check if the path exists
+  if (!pathExists(targetPath)) {
+    return {
+      isValid: false,
+      isDir: false,
+      error: `Path does not exist: ${targetPath}`,
+    };
+  }
+
+  // Check if the path is a directory or file
+  const isDir = isDirectory(targetPath);
+
+  return {
+    isValid: true,
+    isDir,
+  };
+}

package/src/utils/priorityFilter.ts

@@ -0,0 +1,59 @@
+/**
+ * @fileoverview Utility functions for handling priority filters.
+ *
+ * This module provides utility functions for working with priority filters
+ * in interactive mode, including extracting priority filters from command line
+ * arguments and review options.
+ */
+
+import type { ReviewOptions } from '../types/review';
+import type { PriorityFilter } from '../types/common';
+
+/**
+ * Get the priority filter from command line arguments or options
+ *
+ * This function extracts the priority filter from either:
+ * 1. The options object (if the interactive property is a string)
+ * 2. The command line arguments (if --interactive or -i is followed by a priority filter)
+ *
+ * Priority filters determine which issues to display in interactive mode:
+ * - 'h': High priority issues only
+ * - 'm': Medium and high priority issues
+ * - 'l': Low, medium, and high priority issues
+ * - 'a': All issues (including informational)
+ *
+ * @param options Review options that may contain the priority filter
+ * @returns The priority filter (h, m, l, or a) or undefined if not specified
+ * @example
+ * // With options object
+ * const filter = getPriorityFilterFromArgs({ interactive: 'h' });
+ * // filter === 'h'
+ *
+ * // With command line arguments (if process.argv includes '--interactive h')
+ * const filter = getPriorityFilterFromArgs();
+ * // filter === 'h'
+ */
+export function getPriorityFilterFromArgs(options?: ReviewOptions): PriorityFilter | undefined {
+  // First check if the interactive option is a string (priority filter)
+  if (
+    options &&
+    typeof options.interactive === 'string' &&
+    ['h', 'm', 'l', 'a'].includes(options.interactive)
+  ) {
+    return options.interactive as PriorityFilter;
+  }
+
+  // Otherwise check if there's a priority filter argument after --interactive
+  const args = process.argv;
+  const interactiveIndex = args.findIndex((arg) => arg === '--interactive' || arg === '-i');
+
+  if (interactiveIndex !== -1 && interactiveIndex < args.length - 1) {
+    const nextArg = args[interactiveIndex + 1];
+    // Check if the next argument is a priority filter and not another option
+    if (['h', 'm', 'l', 'a'].includes(nextArg) && !nextArg.startsWith('-')) {
+      return nextArg as PriorityFilter;
+    }
+  }
+
+  return undefined;
+}

package/src/utils/projectDocs.ts

@@ -0,0 +1,189 @@
+/**
+ * @fileoverview Utilities for reading and processing project documentation.
+ *
+ * This module provides functionality for reading and processing project documentation
+ * files like README.md, PROJECT.md, and PROGRESS.md. These files provide important
+ * context for code reviews, helping the AI model understand the project's purpose,
+ * structure, and current state.
+ */
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileExists } from './fileSystem';
+import logger from './logger';
+
+/**
+ * Project documentation interface
+ */
+export interface ProjectDocs {
+  readme?: string;
+  project?: string;
+  progress?: string;
+  contributing?: string;
+  architecture?: string;
+  custom?: Record<string, string>;
+  metadata?: Record<string, string>;
+}
+
+/**
+ * Maximum size for documentation files (in characters)
+ * This helps prevent token limit issues
+ */
+const MAX_DOC_SIZE = 50000;
+
+/**
+ * Read a documentation file if it exists
+ * @param filePath File path
+ * @returns File content or undefined if the file doesn't exist
+ */
+async function readDocFile(filePath: string): Promise<string | undefined> {
+  try {
+    if (await fileExists(filePath)) {
+      const content = await fs.readFile(filePath, 'utf-8');
+
+      // Truncate if too large
+      if (content.length > MAX_DOC_SIZE) {
+        logger.warn(
+          `Documentation file ${filePath} is too large, truncating to ${MAX_DOC_SIZE} characters.`,
+        );
+        return `${content.substring(0, MAX_DOC_SIZE)}\n\n[Content truncated due to size]`;
+      }
+
+      return content;
+    }
+  } catch (error) {
+    logger.warn(`Error reading documentation file ${filePath}:`, error);
+  }
+
+  return undefined;
+}
+
+/**
+ * Read project documentation files
+ * @param projectDir Project directory
+ * @returns Project documentation
+ */
+export async function readProjectDocs(projectDir: string): Promise<ProjectDocs> {
+  const docs: ProjectDocs = {
+    custom: {},
+  };
+
+  // Read standard documentation files
+  docs.readme = await readDocFile(path.join(projectDir, 'README.md'));
+  docs.project = await readDocFile(path.join(projectDir, 'PROJECT.md'));
+  docs.progress = await readDocFile(path.join(projectDir, 'PROGRESS.md'));
+  docs.contributing = await readDocFile(path.join(projectDir, 'CONTRIBUTING.md'));
+  docs.architecture = await readDocFile(path.join(projectDir, 'ARCHITECTURE.md'));
+
+  // Read custom documentation files from the docs directory
+  try {
+    const docsDir = path.join(projectDir, 'docs');
+    if (await fileExists(docsDir)) {
+      const files = await fs.readdir(docsDir);
+
+      for (const file of files) {
+        if (file.endsWith('.md')) {
+          const filePath = path.join(docsDir, file);
+          const content = await readDocFile(filePath);
+
+          if (content) {
+            docs.custom![file] = content;
+          }
+        }
+      }
+    }
+  } catch (error) {
+    logger.warn('Error reading docs directory:', error);
+  }
+
+  return docs;
+}
+
+/**
+ * Add metadata to project documentation
+ * @param docs Project documentation object
+ * @param key Metadata key
+ * @param value Metadata value
+ * @returns Project documentation with added metadata
+ */
+export function addMetadataToProjectDocs(
+  docs: ProjectDocs,
+  key: string,
+  value: string,
+): ProjectDocs {
+  if (!docs.metadata) {
+    docs.metadata = {};
+  }
+  docs.metadata[key] = value;
+  return docs;
+}
+
+/**
+ * Format project documentation for inclusion in prompts
+ * @param docs Project documentation
+ * @returns Formatted documentation string
+ */
+export function formatProjectDocs(docs: ProjectDocs): string {
+  const sections: string[] = [];
+
+  if (docs.readme) {
+    sections.push(`# README.md\n\n${docs.readme}`);
+  }
+
+  if (docs.project) {
+    sections.push(`# PROJECT.md\n\n${docs.project}`);
+  }
+
+  if (docs.architecture) {
+    sections.push(`# ARCHITECTURE.md\n\n${docs.architecture}`);
+  }
+
+  if (docs.progress) {
+    sections.push(`# PROGRESS.md\n\n${docs.progress}`);
+  }
+
+  if (docs.contributing) {
+    sections.push(`# CONTRIBUTING.md\n\n${docs.contributing}`);
+  }
+
+  // Add custom documentation files
+  if (docs.custom) {
+    for (const [file, content] of Object.entries(docs.custom)) {
+      sections.push(`# docs/${file}\n\n${content}`);
+    }
+  }
+
+  // Add metadata if present
+  if (docs.metadata) {
+    for (const [key, content] of Object.entries(docs.metadata)) {
+      // Format the metadata section
+      const title = key.charAt(0).toUpperCase() + key.slice(1).replace(/([A-Z])/g, ' $1');
+      sections.push(`# ${title}\n\n${content}`);
+    }
+  }
+
+  if (sections.length === 0) {
+    return '';
+  }
+
+  return `## Project Documentation\n\n${sections.join('\n\n---\n\n')}`;
+}
+
+/**
+ * Add project documentation to a prompt
+ * @param prompt The prompt to add documentation to
+ * @param docs Project documentation object
+ * @returns The prompt with documentation added
+ */
+export function addProjectDocsToPrompt(prompt: string, docs: ProjectDocs): string {
+  const docsText = formatProjectDocs(docs);
+  if (docsText) {
+    // Try to replace a placeholder if it exists
+    if (prompt.includes('{{PROJECT_DOCS}}')) {
+      return prompt.replace('{{PROJECT_DOCS}}', docsText);
+    }
+    // Otherwise, append to the end
+    return `${prompt}\n\n${docsText}`;
+  }
+  return prompt;
+}

package/src/utils/promptPaths.ts

@@ -0,0 +1,29 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Resolve the directory that contains the compiled prompt templates.
+ * The location varies depending on whether we're running from source,
+ * the compiled dist output, or an older workspace layout.
+ */
+export function resolvePromptTemplatesDir(): string {
+  const candidates = [
+    // When running via ts-node from the src tree
+    path.resolve(__dirname, '..', 'prompts', 'promptText'),
+    // When running compiled code while keeping src in the package
+    path.resolve(__dirname, '..', '..', 'src', 'prompts', 'promptText'),
+    // When executing directly from the repo root
+    path.resolve(process.cwd(), 'src', 'prompts', 'promptText'),
+    // Legacy location used before the prompts lived under src/
+    path.resolve(process.cwd(), 'promptText'),
+  ];
+
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  // Fall back to the first option so callers always receive a deterministic path.
+  return candidates[0];
+}

package/src/utils/promptTemplateManager.ts

@@ -0,0 +1,157 @@
+/**
+ * Prompt Template Manager
+ *
+ * This utility provides an interface between the bundledPrompts system
+ * and the new Handlebars template system, enabling a smooth migration.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import type { ReviewType } from '../types/review';
+import logger from './logger';
+import { listAvailableTemplates, loadPromptTemplate } from './templateLoader';
+import { resolvePromptTemplatesDir } from './promptPaths';
+
+/**
+ * Maps framework identifiers from the API to template directory names
+ */
+const frameworkMapping: Record<string, string> = {
+  react: 'react',
+  angular: 'angular',
+  vue: 'vue',
+  'next.js': 'nextjs',
+  nextjs: 'nextjs',
+  django: 'django',
+  flask: 'flask',
+  fastapi: 'fastapi',
+  pyramid: 'pyramid',
+  laravel: 'laravel',
+  flutter: 'flutter',
+};
+
+/**
+ * Maps language identifiers from the API to template directory names
+ */
+const languageMapping: Record<string, string> = {
+  typescript: 'typescript',
+  javascript: 'javascript',
+  js: 'javascript',
+  python: 'python',
+  html: 'html',
+  css: 'css',
+  php: 'php',
+  ruby: 'ruby',
+  dart: 'dart',
+};
+
+/**
+ * Maps ReviewType enum to template file names
+ */
+const reviewTypeMapping: Record<string, string> = {
+  architectural: 'architectural-review',
+  'best-practices': 'best-practices',
+  'quick-fixes': 'quick-fixes-review',
+  security: 'security-review',
+  performance: 'performance-review',
+  'unused-code': 'unused-code-review',
+  'code-tracing-unused-code': 'code-tracing-unused-code-review',
+  'focused-unused-code': 'focused-unused-code-review',
+  'improved-unused-code': 'improved-unused-code-review',
+  consolidated: 'consolidated-review',
+  // Add mapping for improved quick fixes
+  'improved-quick-fixes': 'improved-quick-fixes-review',
+  evaluation: 'evaluation',
+  'extract-patterns': 'extract-patterns-review',
+  'coding-test': 'coding-test',
+  // Contemporary development patterns
+  'ai-integration': 'ai-integration-review',
+  'cloud-native': 'cloud-native-review',
+  'developer-experience': 'developer-experience-review',
+  comprehensive: 'comprehensive',
+};
+
+/**
+ * Get prompt template for the specified review type, language, and framework
+ *
+ * @param reviewType The type of review to get a prompt for
+ * @param language The programming language (optional)
+ * @param framework The framework (optional)
+ * @returns The prompt template string or undefined if not found
+ */
+export function getPromptTemplate(
+  reviewType: ReviewType | string,
+  language?: string,
+  framework?: string,
+): string | undefined {
+  // Convert ReviewType enum to string if needed
+  const reviewTypeStr =
+    typeof reviewType === 'string' ? reviewType : String(reviewType).toLowerCase();
+
+  // Map review type to template file name
+  const templateName = reviewTypeMapping[reviewTypeStr];
+  if (!templateName) {
+    logger.error(`No template mapping found for review type: ${reviewTypeStr}`);
+    return undefined;
+  }
+
+  // Map language and framework to template directory names
+  const mappedLanguage = language ? languageMapping[language.toLowerCase()] : undefined;
+  const mappedFramework = framework ? frameworkMapping[framework.toLowerCase()] : undefined;
+
+  // Try to load the template
+  const template = loadPromptTemplate(templateName, mappedLanguage, mappedFramework);
+
+  return template || undefined;
+}
+
+/**
+ * Check if templates directory exists and is properly structured
+ *
+ * @returns true if templates are available, false otherwise
+ */
+export function checkTemplatesAvailability(): boolean {
+  const templatesDir = resolvePromptTemplatesDir();
+
+  if (!fs.existsSync(templatesDir)) {
+    logger.warn('Templates directory not found. Using bundled prompts instead.');
+    return false;
+  }
+
+  // Check for essential directories
+  const requiredDirs = ['common', 'frameworks', 'languages'];
+  for (const dir of requiredDirs) {
+    if (!fs.existsSync(path.join(templatesDir, dir))) {
+      logger.warn(
+        `Required templates subdirectory '${dir}' not found. Using bundled prompts instead.`,
+      );
+      return false;
+    }
+  }
+
+  // Check for common variables
+  const variablesDir = path.join(templatesDir, 'common', 'variables');
+  if (
+    !fs.existsSync(variablesDir) ||
+    !fs.existsSync(path.join(variablesDir, 'framework-versions.json'))
+  ) {
+    logger.warn('Framework variables data not found. Using bundled prompts instead.');
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Get a list of supported frameworks and languages
+ *
+ * @returns Object containing arrays of supported frameworks, languages, and review types
+ */
+export function getSupportedTemplates(): Record<string, string[]> {
+  return listAvailableTemplates();
+}
+
+export default {
+  getPromptTemplate,
+  checkTemplatesAvailability,
+  getSupportedTemplates,
+};