Sensitivity Check

#!/usr/bin/env -S deno run --allow-read

/**
 * representation-map.ts - Map and analyze character representation
 *
 * Analyzes character data to identify:
 * - Identity distribution
 * - Agency/centrality patterns
 * - Potential trope risks
 * - Diversity within identity groups
 *
 * Usage:
 *   deno run --allow-read representation-map.ts characters.json
 *   deno run --allow-read representation-map.ts --interactive
 *
 * Character JSON format:
 * [
 *   {
 *     "name": "Character Name",
 *     "role": "protagonist|antagonist|supporting|minor",
 *     "identities": {
 *       "race": "...",
 *       "gender": "...",
 *       "sexuality": "...",
 *       "disability": "...",
 *       "other": ["..."]
 *     },
 *     "agency": "high|medium|low",
 *     "arc": "positive|negative|flat|none",
 *     "survives": true|false,
 *     "notes": "..."
 *   }
 * ]
 */

interface CharacterIdentities {
  race?: string;
  gender?: string;
  sexuality?: string;
  disability?: string;
  mentalHealth?: string;
  religion?: string;
  class?: string;
  other?: string[];
}

interface Character {
  name: string;
  role: 'protagonist' | 'antagonist' | 'supporting' | 'minor';
  identities: CharacterIdentities;
  agency: 'high' | 'medium' | 'low';
  arc: 'positive' | 'negative' | 'flat' | 'none';
  survives: boolean;
  notes?: string;
}

interface AnalysisResult {
  characterCount: number;
  roleDistribution: Record<string, number>;
  identityDistribution: Record<string, Record<string, number>>;
  agencyAnalysis: {
    byIdentity: Record<string, { high: number; medium: number; low: number }>;
    concerns: string[];
  };
  survivalAnalysis: {
    byIdentity: Record<string, { survives: number; dies: number }>;
    concerns: string[];
  };
  tropeRisks: string[];
  diversityNotes: string[];
}

const MARGINALIZED_IDENTITIES = {
  race: ['black', 'asian', 'latino', 'latina', 'latinx', 'indigenous', 'native', 'middle eastern', 'south asian', 'pacific islander', 'mixed', 'biracial', 'multiracial'],
  gender: ['woman', 'female', 'trans', 'transgender', 'non-binary', 'nonbinary', 'genderqueer', 'agender', 'genderfluid'],
  sexuality: ['gay', 'lesbian', 'bisexual', 'pansexual', 'queer', 'asexual', 'ace'],
  disability: ['disabled', 'blind', 'deaf', 'wheelchair', 'chronic', 'neurodivergent', 'autistic', 'adhd'],
  mentalHealth: ['depression', 'anxiety', 'ptsd', 'bipolar', 'schizophrenia', 'ocd', 'eating disorder'],
};

function isMarginalized(category: string, value: string): boolean {
  const categoryList = MARGINALIZED_IDENTITIES[category as keyof typeof MARGINALIZED_IDENTITIES];
  if (!categoryList) return false;
  const lowerValue = value.toLowerCase();
  return categoryList.some(term => lowerValue.includes(term));
}

function analyzeCharacters(characters: Character[]): AnalysisResult {
  const result: AnalysisResult = {
    characterCount: characters.length,
    roleDistribution: {},
    identityDistribution: {},
    agencyAnalysis: { byIdentity: {}, concerns: [] },
    survivalAnalysis: { byIdentity: {}, concerns: [] },
    tropeRisks: [],
    diversityNotes: [],
  };

  // Role distribution
  for (const char of characters) {
    result.roleDistribution[char.role] = (result.roleDistribution[char.role] || 0) + 1;
  }

  // Identity distribution
  const identityCategories = ['race', 'gender', 'sexuality', 'disability', 'mentalHealth', 'religion'];
  for (const category of identityCategories) {
    result.identityDistribution[category] = {};
  }

  for (const char of characters) {
    for (const category of identityCategories) {
      const value = char.identities[category as keyof CharacterIdentities];
      if (value && typeof value === 'string') {
        result.identityDistribution[category][value] =
          (result.identityDistribution[category][value] || 0) + 1;
      }
    }
  }

  // Agency analysis by identity
  for (const char of characters) {
    for (const [category, value] of Object.entries(char.identities)) {
      if (value && typeof value === 'string') {
        const key = `${category}:${value}`;
        if (!result.agencyAnalysis.byIdentity[key]) {
          result.agencyAnalysis.byIdentity[key] = { high: 0, medium: 0, low: 0 };
        }
        result.agencyAnalysis.byIdentity[key][char.agency]++;
      }
    }
  }

  // Agency concerns
  for (const [identity, counts] of Object.entries(result.agencyAnalysis.byIdentity)) {
    const total = counts.high + counts.medium + counts.low;
    if (total >= 2) {
      const lowPercentage = (counts.low / total) * 100;
      if (lowPercentage > 50) {
        const [category, value] = identity.split(':');
        if (isMarginalized(category, value)) {
          result.agencyAnalysis.concerns.push(
            `${identity}: ${lowPercentage.toFixed(0)}% low agency (${counts.low}/${total} characters)`
          );
        }
      }
    }
  }

  // Survival analysis
  for (const char of characters) {
    for (const [category, value] of Object.entries(char.identities)) {
      if (value && typeof value === 'string') {
        const key = `${category}:${value}`;
        if (!result.survivalAnalysis.byIdentity[key]) {
          result.survivalAnalysis.byIdentity[key] = { survives: 0, dies: 0 };
        }
        if (char.survives) {
          result.survivalAnalysis.byIdentity[key].survives++;
        } else {
          result.survivalAnalysis.byIdentity[key].dies++;
        }
      }
    }
  }

  // Survival concerns
  for (const [identity, counts] of Object.entries(result.survivalAnalysis.byIdentity)) {
    const total = counts.survives + counts.dies;
    if (counts.dies > 0) {
      const deathPercentage = (counts.dies / total) * 100;
      const [category, value] = identity.split(':');
      if (isMarginalized(category, value)) {
        if (deathPercentage > 50 || (category === 'sexuality' && counts.dies > 0)) {
          result.survivalAnalysis.concerns.push(
            `${identity}: ${counts.dies}/${total} characters die (${deathPercentage.toFixed(0)}%)`
          );
        }
      }
    }
  }

  // Trope risk detection
  const lgbtqChars = characters.filter(c =>
    isMarginalized('sexuality', c.identities.sexuality || '') ||
    (c.identities.gender && isMarginalized('gender', c.identities.gender) && c.identities.gender.toLowerCase().includes('trans'))
  );
  const lgbtqDeaths = lgbtqChars.filter(c => !c.survives);
  if (lgbtqDeaths.length > 0) {
    result.tropeRisks.push(
      `BURY YOUR GAYS RISK: ${lgbtqDeaths.length} LGBTQ+ character(s) die: ${lgbtqDeaths.map(c => c.name).join(', ')}`
    );
  }

  // Magical minority detection
  const marginalizedSupportingWithHighAgency = characters.filter(c =>
    c.role === 'supporting' &&
    c.agency === 'high' &&
    Object.entries(c.identities).some(([cat, val]) =>
      val && typeof val === 'string' && isMarginalized(cat, val)
    )
  );
  const protagonists = characters.filter(c => c.role === 'protagonist');
  const defaultProtagonists = protagonists.filter(c =>
    !Object.entries(c.identities).some(([cat, val]) =>
      val && typeof val === 'string' && isMarginalized(cat, val)
    )
  );

  if (marginalizedSupportingWithHighAgency.length > 0 && defaultProtagonists.length > 0) {
    result.tropeRisks.push(
      `MAGICAL MINORITY RISK: Marginalized supporting characters with high agency serving default protagonist(s). Check: ${marginalizedSupportingWithHighAgency.map(c => c.name).join(', ')}`
    );
  }

  // Mental health + antagonist
  const mentalHealthAntagonists = characters.filter(c =>
    c.role === 'antagonist' && c.identities.mentalHealth
  );
  if (mentalHealthAntagonists.length > 0) {
    result.tropeRisks.push(
      `MENTAL ILLNESS = VILLAIN RISK: Antagonist(s) with mental health conditions: ${mentalHealthAntagonists.map(c => `${c.name} (${c.identities.mentalHealth})`).join(', ')}`
    );
  }

  // Diversity notes
  const identityCounts: Record<string, number> = {};
  for (const char of characters) {
    for (const [category, value] of Object.entries(char.identities)) {
      if (value && typeof value === 'string') {
        const key = `${category}:${value}`;
        identityCounts[key] = (identityCounts[key] || 0) + 1;
      }
    }
  }

  for (const [identity, count] of Object.entries(identityCounts)) {
    if (count === 1) {
      const [category, value] = identity.split(':');
      if (isMarginalized(category, value)) {
        result.diversityNotes.push(
          `Only one ${value} character - consider if tokenism risk`
        );
      }
    }
  }

  return result;
}

function formatReport(result: AnalysisResult): string {
  let report = `
REPRESENTATION MAP
==================

Characters analyzed: ${result.characterCount}

ROLE DISTRIBUTION
`;
  for (const [role, count] of Object.entries(result.roleDistribution)) {
    report += `  ${role}: ${count}\n`;
  }

  report += `
IDENTITY DISTRIBUTION
`;
  for (const [category, values] of Object.entries(result.identityDistribution)) {
    if (Object.keys(values).length > 0) {
      report += `\n  ${category}:\n`;
      for (const [value, count] of Object.entries(values)) {
        report += `    ${value}: ${count}\n`;
      }
    }
  }

  if (result.agencyAnalysis.concerns.length > 0) {
    report += `
AGENCY CONCERNS
`;
    for (const concern of result.agencyAnalysis.concerns) {
      report += `  ! ${concern}\n`;
    }
  }

  if (result.survivalAnalysis.concerns.length > 0) {
    report += `
SURVIVAL CONCERNS
`;
    for (const concern of result.survivalAnalysis.concerns) {
      report += `  ! ${concern}\n`;
    }
  }

  if (result.tropeRisks.length > 0) {
    report += `
TROPE RISKS
`;
    for (const risk of result.tropeRisks) {
      report += `  !! ${risk}\n`;
    }
  }

  if (result.diversityNotes.length > 0) {
    report += `
DIVERSITY NOTES
`;
    for (const note of result.diversityNotes) {
      report += `  * ${note}\n`;
    }
  }

  report += `
RECOMMENDATIONS

1. Review any flagged trope risks carefully
2. Consider agency distribution across identities
3. If only one character of an identity, consider tokenism
4. Ensure marginalized characters have their own stories/arcs
5. Engage sensitivity readers for identities represented

This analysis is based on data provided and cannot assess:
  - Quality of representation within the narrative
  - Stereotyping through characterization
  - Authentic voice and experience
  - Reception by affected communities
`;

  return report;
}

function showExampleFormat(): string {
  return `
CHARACTER JSON FORMAT
=====================

Create a JSON file with this structure:

[
  {
    "name": "Maya Chen",
    "role": "protagonist",
    "identities": {
      "race": "Chinese-American",
      "gender": "woman",
      "sexuality": "bisexual",
      "disability": null,
      "mentalHealth": null,
      "religion": null
    },
    "agency": "high",
    "arc": "positive",
    "survives": true,
    "notes": "Main character, drives the plot"
  },
  {
    "name": "James Wright",
    "role": "supporting",
    "identities": {
      "race": "white",
      "gender": "man",
      "sexuality": "straight"
    },
    "agency": "medium",
    "arc": "flat",
    "survives": true
  },
  {
    "name": "Dr. Amara Okonkwo",
    "role": "supporting",
    "identities": {
      "race": "Nigerian",
      "gender": "woman",
      "sexuality": "lesbian"
    },
    "agency": "high",
    "arc": "positive",
    "survives": false,
    "notes": "Dies in chapter 15"
  }
]

FIELDS:
  name: Character name
  role: protagonist | antagonist | supporting | minor
  identities: Object with identity categories
    - race: ethnic/racial identity
    - gender: gender identity
    - sexuality: sexual orientation
    - disability: any disability
    - mentalHealth: any mental health condition
    - religion: religious identity
    - class: socioeconomic class
  agency: high | medium | low (how much they drive events)
  arc: positive | negative | flat | none
  survives: true | false (do they survive the story?)
  notes: optional additional context
`;
}

function showUsage(): void {
  console.log(`
Representation Map Tool
=======================

Analyzes character data to identify representation patterns.

Usage:
  deno run --allow-read representation-map.ts <characters.json>
  deno run --allow-read representation-map.ts --format

Options:
  --format    Show the expected JSON format for character data

Detects:
  - Identity distribution across characters
  - Agency imbalances by identity
  - Survival disparities (Bury Your Gays, etc.)
  - Trope risks (Magical Minority, etc.)
  - Tokenism indicators

See --format for character JSON structure.
`);
}

async function main() {
  const args = Deno.args;

  if (args.includes('--format')) {
    console.log(showExampleFormat());
    Deno.exit(0);
  }

  if (args.length === 0 || args[0].startsWith('--')) {
    showUsage();
    Deno.exit(0);
  }

  const filename = args[0];
  try {
    const text = await Deno.readTextFile(filename);
    const characters: Character[] = JSON.parse(text);

    if (!Array.isArray(characters)) {
      console.error('Error: JSON must be an array of character objects');
      Deno.exit(1);
    }

    const result = analyzeCharacters(characters);
    console.log(formatReport(result));
  } catch (e) {
    if (e instanceof SyntaxError) {
      console.error('Error: Invalid JSON format');
      console.error(e.message);
    } else {
      console.error(`Error reading file: ${filename}`);
      console.error(e);
    }
    Deno.exit(1);
  }
}

main();

#!/usr/bin/env -S deno run --allow-read

/**
 * sensitivity-audit.ts - Pattern scanner for potential representation concerns
 *
 * IMPORTANT: This tool flags patterns for HUMAN REVIEW. It cannot determine
 * context, intent, or whether a pattern is actually problematic. Every flag
 * requires human evaluation.
 *
 * Detects:
 * - Potential stereotyping language patterns
 * - Uneven physical description patterns
 * - Common harmful trope markers
 * - Agency/voice distribution indicators
 *
 * Usage:
 *   deno run --allow-read sensitivity-audit.ts manuscript.txt
 *   deno run --allow-read sensitivity-audit.ts --text "Sample passage..."
 */

interface PatternMatch {
  category: string;
  pattern: string;
  line: number;
  text: string;
  note: string;
}

interface AuditResult {
  totalLines: number;
  flags: PatternMatch[];
  summary: Record<string, number>;
}

// Physical description patterns that may indicate gendered gaze
const PHYSICAL_DESCRIPTION_PATTERNS = [
  { pattern: /\b(her|she|woman's|girl's)\s+(body|figure|curves|breasts|legs|hips|waist|lips|skin)\b/gi, note: "Physical description of female body - check for male gaze" },
  { pattern: /\b(beautiful|gorgeous|stunning|sexy|attractive)\s+(woman|girl|she|her)\b/gi, note: "Appearance-focused female description - check balance with male characters" },
  { pattern: /\bher\s+(ample|full|heaving|soft)\s+/gi, note: "Potentially objectifying description - review context" },
];

// Stereotyping language patterns (require context review)
const STEREOTYPE_PATTERNS = [
  // General
  { pattern: /\b(exotic|oriental)\b/gi, note: "Potentially othering language - review context" },
  { pattern: /\b(tribe|tribal)\b/gi, note: "May be appropriate or stereotyping - review context" },
  { pattern: /\bbroken\s+english\b/gi, note: "Dialect representation - check if respectful or mocking" },

  // Agency markers
  { pattern: /\bsaved\s+(her|him|them)\s+from\b/gi, note: "Savior dynamic - check who saves whom" },
  { pattern: /\bteach\s+(her|him|them)\s+(about|how)\b/gi, note: "Teaching dynamic - check power dynamics" },
  { pattern: /\bexplain(ed|ing)?\s+(to|for)\s+(her|him|them)\b/gi, note: "Explaining dynamic - check condescension" },
];

// Trope markers (require context review)
const TROPE_PATTERNS = [
  // Death/suffering
  { pattern: /\b(died|killed|death)\b.*\b(gay|lesbian|bisexual|trans|queer)\b/gi, note: "LGBTQ+ character death - check for Bury Your Gays pattern" },
  { pattern: /\b(gay|lesbian|bisexual|trans|queer)\b.*\b(died|killed|death)\b/gi, note: "LGBTQ+ character death - check for Bury Your Gays pattern" },

  // Magical/mystical minority
  { pattern: /\b(wise|wisdom|ancient|mystical|spiritual)\s+(elder|grandmother|grandfather|old\s+(man|woman))\b/gi, note: "Wisdom figure - check for Magical Minority trope" },

  // Mental health
  { pattern: /\b(crazy|insane|psycho|lunatic|mental)\s+(killer|murderer|villain)\b/gi, note: "Mental illness = violence pattern - review carefully" },
  { pattern: /\b(schizophren|bipolar|psychotic)\b.*\b(dangerous|violent|killer)\b/gi, note: "Specific diagnosis linked to violence - major concern" },
];

// Disability language patterns
const DISABILITY_PATTERNS = [
  { pattern: /\b(wheelchair\s*bound|confined\s+to\s+(a\s+)?wheelchair)\b/gi, note: "Outdated disability language - prefer 'uses a wheelchair'" },
  { pattern: /\b(suffer(s|ed|ing)?\s+from|afflicted\s+(with|by))\b/gi, note: "Suffering framing - may be othering; review context" },
  { pattern: /\b(despite\s+(his|her|their)\s+disability)\b/gi, note: "Inspiration porn marker - review for 'overcoming' narrative" },
  { pattern: /\b(special\s+needs)\b/gi, note: "Euphemism - consider if 'disabled' is more direct and preferred" },
  { pattern: /\bthe\s+(blind|deaf|disabled|crippled|handicapped)\b/gi, note: "Group-noun usage - prefer person-first or identity-first per community" },
];

// Body size patterns
const BODY_PATTERNS = [
  { pattern: /\b(fat|obese|overweight)\s+(and|but)\s+(lazy|slovenly|gross|disgusting)\b/gi, note: "Weight + negative trait - check for fatphobic stereotyping" },
  { pattern: /\blet\s+(herself|himself|themselves)\s+go\b/gi, note: "Weight judgment - review for moralizing body size" },
  { pattern: /\b(thin|slim|slender)\s+(and|but)\s+(beautiful|attractive|healthy)\b/gi, note: "Thin = positive pattern - review for anti-fat bias" },
];

// Dialogue patterns that might indicate same-voice issues across identities
const DIALOGUE_PATTERNS = [
  { pattern: /\b(yes,?\s+massa|yessir|lawdy|chile)\b/gi, note: "Dialect representation - verify authenticity, check for minstrelsy" },
  { pattern: /\bme\s+(love|want|no\s+understand)\b/gi, note: "Broken speech pattern - check for mocking vs. authentic ESL" },
];

function matchPatterns(text: string, patterns: { pattern: RegExp; note: string }[], category: string): PatternMatch[] {
  const lines = text.split('\n');
  const matches: PatternMatch[] = [];

  for (let i = 0; i < lines.length; i++) {
    const line = lines[i];
    for (const { pattern, note } of patterns) {
      pattern.lastIndex = 0;
      let match;
      while ((match = pattern.exec(line)) !== null) {
        matches.push({
          category,
          pattern: match[0],
          line: i + 1,
          text: line.trim().slice(0, 100) + (line.length > 100 ? '...' : ''),
          note,
        });
      }
    }
  }

  return matches;
}

function analyzeText(text: string): AuditResult {
  const lines = text.split('\n');
  const flags: PatternMatch[] = [];

  flags.push(...matchPatterns(text, PHYSICAL_DESCRIPTION_PATTERNS, 'Physical Description'));
  flags.push(...matchPatterns(text, STEREOTYPE_PATTERNS, 'Stereotyping Language'));
  flags.push(...matchPatterns(text, TROPE_PATTERNS, 'Harmful Tropes'));
  flags.push(...matchPatterns(text, DISABILITY_PATTERNS, 'Disability Language'));
  flags.push(...matchPatterns(text, BODY_PATTERNS, 'Body Size'));
  flags.push(...matchPatterns(text, DIALOGUE_PATTERNS, 'Dialogue Patterns'));

  // Sort by line number
  flags.sort((a, b) => a.line - b.line);

  // Summarize by category
  const summary: Record<string, number> = {};
  for (const flag of flags) {
    summary[flag.category] = (summary[flag.category] || 0) + 1;
  }

  return {
    totalLines: lines.length,
    flags,
    summary,
  };
}

function formatReport(result: AuditResult): string {
  let report = `
SENSITIVITY AUDIT
=================

IMPORTANT: This tool flags patterns for HUMAN REVIEW.
It cannot determine context, intent, or actual harm.
Every flag requires thoughtful human evaluation.

Lines scanned: ${result.totalLines}
Patterns flagged: ${result.flags.length}

`;

  if (Object.keys(result.summary).length > 0) {
    report += `SUMMARY BY CATEGORY\n`;
    for (const [category, count] of Object.entries(result.summary)) {
      report += `  ${category}: ${count} flag(s)\n`;
    }
    report += '\n';
  }

  if (result.flags.length === 0) {
    report += `No patterns flagged. This does NOT mean the text is free of concerns.
Pattern matching cannot catch:
  - Stereotyping through characterization (not language)
  - Agency imbalances in plot structure
  - Tropes enacted through events rather than words
  - Subtle or contextual issues

Consider full human sensitivity reading for thorough evaluation.
`;
  } else {
    report += `FLAGGED PATTERNS\n`;
    report += `${'='.repeat(50)}\n\n`;

    let currentCategory = '';
    for (const flag of result.flags) {
      if (flag.category !== currentCategory) {
        currentCategory = flag.category;
        report += `\n## ${currentCategory}\n\n`;
      }

      report += `Line ${flag.line}: "${flag.pattern}"\n`;
      report += `  Context: ${flag.text}\n`;
      report += `  Note: ${flag.note}\n\n`;
    }

    report += `
${'='.repeat(50)}

NEXT STEPS

1. Review each flag in context - many may be appropriate
2. For concerning patterns, consider:
   - Is this character/scene necessary?
   - Could this be written differently?
   - What might affected readers experience?
3. Consider engaging sensitivity readers for identities represented
4. Pattern absence doesn't mean concern absence - structural issues
   (plot, character agency, tropes) require human analysis

This tool supplements but does NOT replace human sensitivity reading.
`;
  }

  return report;
}

function showUsage(): void {
  console.log(`
Sensitivity Audit Tool
======================

Scans text for patterns that may indicate representation concerns.
Flags for HUMAN REVIEW - cannot determine actual harm.

Usage:
  deno run --allow-read sensitivity-audit.ts <file>
  deno run --allow-read sensitivity-audit.ts --text "Text to analyze..."

Pattern Categories:
  - Physical Description: Gendered gaze, objectification
  - Stereotyping Language: Othering, power dynamics
  - Harmful Tropes: Known problematic patterns
  - Disability Language: Outdated or othering terms
  - Body Size: Fatphobic patterns
  - Dialogue Patterns: Accent/dialect representation

IMPORTANT: This tool cannot catch:
  - Characterization-based stereotyping
  - Plot-level agency imbalances
  - Tropes enacted through events
  - Contextual or subtle issues

Always engage human sensitivity readers for thorough evaluation.
`);
}

async function main() {
  const args = Deno.args;
  let text: string;

  if (args.includes('--text')) {
    const textIndex = args.indexOf('--text');
    text = args.slice(textIndex + 1).join(' ');
  } else if (args.length > 0 && !args[0].startsWith('--')) {
    const filename = args[0];
    try {
      text = await Deno.readTextFile(filename);
    } catch (e) {
      console.error(`Error reading file: ${filename}`);
      console.error(e);
      Deno.exit(1);
    }
  } else {
    showUsage();
    Deno.exit(0);
  }

  const result = analyzeText(text);
  console.log(formatReport(result));
}

main();