only_ever_generator 8.0.2 → 8.0.4

package/src/parsers/content_parser.ts

@@ -1,90 +0,0 @@
-/**
- * Standalone ContentParser module
- * Parses and sanitizes source content
- */
-
-import { ParseSourceContent } from "../parse/parse_source_content";
-import {
-  ContentParserConfig,
-  DEFAULT_CONTENT_PARSER_CONFIG,
-} from "../configs/parser_config";
-import { validateContentType } from "../utils/validation";
-
-export interface ParsedContent {
-  source_id: string;
-  type: string;
-  title: string;
-  content: any[];
-  headings: string[];
-  taxonomy?: any;
-}
-
-export class ContentParser {
-  private config: ContentParserConfig;
-
-  constructor(config: ContentParserConfig) {
-    this.validateConfig(config);
-    this.config = { ...DEFAULT_CONTENT_PARSER_CONFIG, ...config };
-  }
-
-  /**
-   * Parse raw content into structured format
-   */
-  parse(rawContent: any): ParsedContent {
-    // Create a custom ParseSourceContent instance with our config
-    const parser = new ParseSourceContent(rawContent);
-
-    // Override the default titles and block types if provided
-    if (this.config.titlesToRemove) {
-      parser.titles_to_remove = this.config.titlesToRemove;
-    }
-
-    if (this.config.blockTypesToRemove) {
-      parser.block_types_toremove = this.config.blockTypesToRemove;
-    }
-
-    const parsedData = parser.parseData();
-
-    return {
-      source_id: parsedData.source_id,
-      type: parsedData.type,
-      title: parsedData.title,
-      content: parsedData.content,
-      headings: parsedData.headings,
-      taxonomy: parsedData.taxonomy,
-    };
-  }
-
-  /**
-   * Parse video content with timecode collapsing
-   */
-  parseVideoContent(rawContent: any): ParsedContent {
-    const parser = new ParseSourceContent(rawContent);
-
-    // Override the collapse timecodes method if max duration is specified
-    if (this.config.maxTimecodeDuration) {
-      const originalCollapseTimeCodes = parser.collapseTimeCodes.bind(parser);
-      parser.collapseTimeCodes = (
-        data: any[],
-        maxDuration = this.config.maxTimecodeDuration
-      ) => {
-        return originalCollapseTimeCodes(data, maxDuration);
-      };
-    }
-
-    const parsedData = parser.parseData();
-
-    return {
-      source_id: parsedData.source_id,
-      type: parsedData.type,
-      title: parsedData.title,
-      content: parsedData.content,
-      headings: parsedData.headings,
-      taxonomy: parsedData.taxonomy,
-    };
-  }
-
-  private validateConfig(config: ContentParserConfig): void {
-    validateContentType(config.type);
-  }
-}

package/src/utils/validation.ts

@@ -1,298 +0,0 @@
-/**
- * Input validation utilities for OnlyEver Generator
- */
-
-export class ValidationError extends Error {
-  constructor(message: string, public field?: string) {
-    super(message);
-    this.name = "ValidationError";
-  }
-}
-
-/**
- * Validates that a value is not null or undefined
- */
-export function validateRequired<T>(
-  value: T | null | undefined,
-  fieldName: string
-): T {
-  if (value === null || value === undefined) {
-    throw new ValidationError(`${fieldName} is required`, fieldName);
-  }
-  return value;
-}
-
-/**
- * Validates that a string is not empty
- */
-export function validateNonEmptyString(
-  value: string | null | undefined,
-  fieldName: string
-): string {
-  const validated = validateRequired(value, fieldName);
-  if (typeof validated !== "string" || validated.trim().length === 0) {
-    throw new ValidationError(
-      `${fieldName} must be a non-empty string`,
-      fieldName
-    );
-  }
-  return validated;
-}
-
-/**
- * Validates that a value is a positive number
- */
-export function validatePositiveNumber(
-  value: number | null | undefined,
-  fieldName: string
-): number {
-  const validated = validateRequired(value, fieldName);
-  if (typeof validated !== "number" || validated <= 0) {
-    throw new ValidationError(
-      `${fieldName} must be a positive number`,
-      fieldName
-    );
-  }
-  return validated;
-}
-
-/**
- * Validates that a number is within a range
- */
-export function validateNumberRange(
-  value: number | null | undefined,
-  fieldName: string,
-  min: number,
-  max: number
-): number {
-  const validated = validateRequired(value, fieldName);
-  if (typeof validated !== "number" || validated < min || validated > max) {
-    throw new ValidationError(
-      `${fieldName} must be between ${min} and ${max}`,
-      fieldName
-    );
-  }
-  return validated;
-}
-
-/**
- * Validates that a value is one of the allowed values
- */
-export function validateEnum<T extends string>(
-  value: T | null | undefined,
-  fieldName: string,
-  allowedValues: readonly T[]
-): T {
-  const validated = validateRequired(value, fieldName);
-  if (!allowedValues.includes(validated)) {
-    throw new ValidationError(
-      `${fieldName} must be one of: ${allowedValues.join(", ")}`,
-      fieldName
-    );
-  }
-  return validated;
-}
-
-/**
- * Validates that a value is an array with at least one element
- */
-export function validateNonEmptyArray<T>(
-  value: T[] | null | undefined,
-  fieldName: string
-): T[] {
-  const validated = validateRequired(value, fieldName);
-  if (!Array.isArray(validated) || validated.length === 0) {
-    throw new ValidationError(
-      `${fieldName} must be a non-empty array`,
-      fieldName
-    );
-  }
-  return validated;
-}
-
-/**
- * Validates OpenAI API key format
- */
-export function validateOpenAIKey(apiKey: string | null | undefined): string {
-  const validated = validateNonEmptyString(apiKey, "OpenAI API key");
-
-  // Basic format validation for OpenAI API keys
-  if (!validated.startsWith("sk-")) {
-    throw new ValidationError('OpenAI API key must start with "sk-"', "apiKey");
-  }
-
-  if (validated.length < 20) {
-    throw new ValidationError(
-      "OpenAI API key appears to be too short",
-      "apiKey"
-    );
-  }
-
-  return validated;
-}
-
-/**
- * Validates OpenAI model name
- */
-export function validateOpenAIModel(model: string | null | undefined): string {
-  const validated = validateNonEmptyString(model, "OpenAI model");
-
-  // Common OpenAI model patterns
-  const validModels = [
-    "gpt-4o",
-    "gpt-4o-mini",
-    "gpt-4",
-    "gpt-4-turbo",
-    "gpt-3.5-turbo",
-    "gpt-3.5-turbo-16k",
-  ];
-
-  if (!validModels.some((validModel) => validated.startsWith(validModel))) {
-    console.warn(
-      `Model "${validated}" may not be a valid OpenAI model. Valid models include: ${validModels.join(
-        ", "
-      )}`
-    );
-  }
-
-  return validated;
-}
-
-/**
- * Validates prompt ID format
- */
-export function validatePromptId(
-  promptId: string | null | undefined,
-  fieldName: string
-): string {
-  const validated = validateNonEmptyString(promptId, fieldName);
-
-  // Basic format validation for prompt IDs
-  if (!validated.startsWith("pmpt_")) {
-    throw new ValidationError(
-      `${fieldName} must start with "pmpt_"`,
-      fieldName
-    );
-  }
-
-  if (validated.length < 10) {
-    throw new ValidationError(
-      `${fieldName} appears to be too short`,
-      fieldName
-    );
-  }
-
-  return validated;
-}
-
-/**
- * Validates content type
- */
-export function validateContentType(type: string | null | undefined): string {
-  return validateEnum(type, "content type", ["text", "video"] as const);
-}
-
-/**
- * Validates source ID format
- */
-export function validateSourceId(sourceId: string | null | undefined): string {
-  const validated = validateNonEmptyString(sourceId, "source ID");
-
-  // Basic validation - should be a reasonable length
-  if (validated.length < 3) {
-    throw new ValidationError(
-      "Source ID must be at least 3 characters long",
-      "sourceId"
-    );
-  }
-
-  return validated;
-}
-
-/**
- * Validates similarity threshold
- */
-export function validateSimilarityThreshold(
-  threshold: number | null | undefined,
-  fieldName: string
-): number {
-  return validateNumberRange(threshold, fieldName, 0, 1);
-}
-
-/**
- * Validates embedding dimensions
- */
-export function validateEmbeddingDimensions(
-  dimensions: number | null | undefined
-): number {
-  const validated = validateRequired(dimensions, "embedding dimensions");
-
-  // Common embedding dimensions
-  const validDimensions = [128, 256, 512, 768, 1024, 1536, 2048];
-
-  if (!validDimensions.includes(validated)) {
-    console.warn(
-      `Embedding dimensions ${validated} may not be standard. Common values: ${validDimensions.join(
-        ", "
-      )}`
-    );
-  }
-
-  return validated;
-}
-
-/**
- * Validates that an object has required properties
- */
-export function validateObjectProperties<T extends Record<string, any>>(
-  obj: T | null | undefined,
-  fieldName: string,
-  requiredProperties: (keyof T)[]
-): T {
-  const validated = validateRequired(obj, fieldName);
-
-  for (const prop of requiredProperties) {
-    if (
-      !(prop in validated) ||
-      validated[prop] === null ||
-      validated[prop] === undefined
-    ) {
-      throw new ValidationError(
-        `${fieldName} must have property "${String(prop)}"`,
-        fieldName
-      );
-    }
-  }
-
-  return validated;
-}
-
-/**
- * Validates array of strings
- */
-export function validateStringArray(
-  value: string[] | null | undefined,
-  fieldName: string,
-  allowEmpty: boolean = true
-): string[] {
-  const validated = validateRequired(value, fieldName);
-
-  if (!Array.isArray(validated)) {
-    throw new ValidationError(`${fieldName} must be an array`, fieldName);
-  }
-
-  if (!allowEmpty && validated.length === 0) {
-    throw new ValidationError(`${fieldName} must not be empty`, fieldName);
-  }
-
-  for (let i = 0; i < validated.length; i++) {
-    if (typeof validated[i] !== "string") {
-      throw new ValidationError(
-        `${fieldName}[${i}] must be a string`,
-        fieldName
-      );
-    }
-  }
-
-  return validated;
-}