Fallacy Detection

type ArgumentNode = {
  // ... other fields
  fallacies: string[];  // Array of fallacy names (empty if none)
}

// No fallacies detected
fallacies: []

// Single fallacy
fallacies: ["Ad Hominem"]

// Multiple fallacies
fallacies: ["Straw Man", "False Dilemma", "Appeal to Authority"]

type IdentifyLogicalFallaciesInput = {
  argumentText: string;  // The text of the argument to analyze
}

type IdentifyLogicalFallaciesOutput = {
  fallacies: string[];        // Array of fallacy names
  explanation: string;        // Detailed explanation of each fallacy
}

const prompt = ai.definePrompt({
  name: 'identifyLogicalFallaciesPrompt',
  prompt: `You are an expert in logical fallacies. Identify any 
           logical fallacies present in the given argument text 
           and provide a detailed explanation for each fallacy.`
});

┌──────────────────────────────┐
│ [Type Badge]                 │
│ Argument content here...     │
│                              │
│ ⚠️  Contains logical fallacy │
└──────────────────────────────┘

┌─────────────────────────────────────┐
│ [Argument Details]                  │
├─────────────────────────────────────┤
│ ⚠️  Logical Fallacies               │
│ ┌─────────────────────────────────┐ │
│ │ [Ad Hominem]  [Straw Man]       │ │
│ └─────────────────────────────────┘ │
│                                     │
│ Detailed explanation of why these   │
│ fallacies apply to this argument... │
└─────────────────────────────────────┘

// Thesis node - rarely has fallacies (it's a proposition)
{
  type: 'thesis',
  content: 'AI should be regulated',
  fallacies: []  // Propositions typically don't contain fallacies
}

// Claim node - analyzed for logical errors
{
  type: 'claim',
  content: 'Everyone agrees AI is dangerous, so regulation is needed',
  fallacies: ['Appeal to Popularity', 'Hasty Generalization']
}

// Evidence node - analyzed for reliability
{
  type: 'evidence',
  content: 'One tech CEO said AI could be risky',
  fallacies: ['Anecdotal Evidence', 'Appeal to Authority']
}

{
  content: 'Opponents of this policy are just naive idealists',
  fallacies: ['Ad Hominem'],
  logicalRole: 'Attempts to dismiss opposition by attacking character',
  // ⚠️ This combination reveals both WHAT the fallacy is and 
  // HOW it undermines the argument structure
}

const fallacious = blueprint.filter(
  node => node.fallacies.length > 0
);

console.log(`${fallacious.length} arguments contain logical fallacies`);

const forFallacies = blueprint.filter(
  node => node.side === 'for' && node.fallacies.length > 0
).length;

const againstFallacies = blueprint.filter(
  node => node.side === 'against' && node.fallacies.length > 0
).length;

// Which side relies more on fallacious reasoning?

const allFallacies = blueprint
  .flatMap(node => node.fallacies)
  .reduce((acc, fallacy) => {
    acc[fallacy] = (acc[fallacy] || 0) + 1;
    return acc;
  }, {});

// Shows frequency distribution of fallacy types