src/stm/modules.ts

/**
 * Semantic Transformation Modules (STM)
 * Modular behavioral/linguistic transformers for AI outputs
 */

export interface STMModule {
  id: string
  name: string
  description: string
  version: string
  author: string
  enabled: boolean
  config?: Record<string, unknown>
  transformer: (input: string, config?: Record<string, unknown>) => string
}

/**
 * Hedge Reducer
 * Removes hedging language like "I think", "maybe", "perhaps"
 */
export const hedgeReducer: STMModule = {
  id: 'hedge_reducer',
  name: 'Hedge Reducer',
  description: 'Reduces hedging language for more confident responses',
  version: '1.0.0',
  author: 'G0DM0D3',
  enabled: false,
  transformer: (input: string) => {
    const hedges = [
      /\bI think\s+/gi,
      /\bI believe\s+/gi,
      /\bperhaps\s+/gi,
      /\bmaybe\s+/gi,
      /\bIt seems like\s+/gi,
      /\bIt appears that\s+/gi,
      /\bprobably\s+/gi,
      /\bpossibly\s+/gi,
      /\bI would say\s+/gi,
      /\bIn my opinion,?\s*/gi,
      /\bFrom my perspective,?\s*/gi
    ]

    let result = input
    for (const hedge of hedges) {
      result = result.replace(hedge, '')
    }

    // Capitalize first letter of sentences after removal
    result = result.replace(/^\s*([a-z])/gm, (_, letter) => letter.toUpperCase())

    return result
  }
}

/**
 * Direct Mode
 * Removes preambles and gets straight to the point
 */
export const directMode: STMModule = {
  id: 'direct_mode',
  name: 'Direct Mode',
  description: 'Removes preambles and filler phrases',
  version: '1.0.0',
  author: 'G0DM0D3',
  enabled: false,
  transformer: (input: string) => {
    const preambles = [
      /^(Sure,?\s*)/i,
      /^(Of course,?\s*)/i,
      /^(Certainly,?\s*)/i,
      /^(Absolutely,?\s*)/i,
      /^(Great question!?\s*)/i,
      /^(That's a great question!?\s*)/i,
      /^(I'd be happy to help( you)?( with that)?[.!]?\s*)/i,
      /^(Let me help you with that[.!]?\s*)/i,
      /^(I understand[.!]?\s*)/i,
      /^(Thanks for asking[.!]?\s*)/i
    ]

    let result = input
    for (const preamble of preambles) {
      result = result.replace(preamble, '')
    }

    // Capitalize first letter
    result = result.replace(/^\s*([a-z])/, (_, letter) => letter.toUpperCase())

    return result
  }
}

/**
 * Casual Mode
 * Converts formal language to casual speech
 */
export const casualMode: STMModule = {
  id: 'casual_mode',
  name: 'Casual Mode',
  description: 'Converts formal language to casual speech',
  version: '1.0.0',
  author: 'G0DM0D3',
  enabled: false,
  transformer: (input: string) => {
    return input
      .replace(/\bHowever\b/g, 'But')
      .replace(/\bTherefore\b/g, 'So')
      .replace(/\bFurthermore\b/g, 'Also')
      .replace(/\bAdditionally\b/g, 'Plus')
      .replace(/\bNevertheless\b/g, 'Still')
      .replace(/\bConsequently\b/g, 'So')
      .replace(/\bMoreover\b/g, 'Also')
      .replace(/\bUtilize\b/g, 'Use')
      .replace(/\butilize\b/g, 'use')
      .replace(/\bPurchase\b/g, 'Buy')
      .replace(/\bpurchase\b/g, 'buy')
      .replace(/\bObtain\b/g, 'Get')
      .replace(/\bobtain\b/g, 'get')
      .replace(/\bCommence\b/g, 'Start')
      .replace(/\bcommence\b/g, 'start')
      .replace(/\bTerminate\b/g, 'End')
      .replace(/\bterminate\b/g, 'end')
      .replace(/\bPrior to\b/gi, 'Before')
      .replace(/\bSubsequent to\b/gi, 'After')
      .replace(/\bIn order to\b/gi, 'To')
      .replace(/\bDue to the fact that\b/gi, 'Because')
      .replace(/\bAt this point in time\b/gi, 'Now')
      .replace(/\bIn the event that\b/gi, 'If')
  }
}

/**
 * Export all modules
 */
export const allModules: STMModule[] = [
  hedgeReducer,
  directMode,
  casualMode
]

/**
 * Apply enabled STM modules to text
 */
export function applySTMs(text: string, modules: STMModule[]): string {
  let result = text

  for (const module of modules) {
    if (module.enabled) {
      result = module.transformer(result, module.config)
    }
  }

  return result
}