tractatus/scripts/analyze-applicability-to-family-history.js

#!/usr/bin/env node

/**
 * Analyze Tractatus instructions for applicability to family-history
 *
 * Categories:
 * 1. Already Applicable - Can use immediately (general development practices)
 * 2. Applicable but Blocked - Needs framework infrastructure first
 * 3. Not Applicable - Tractatus-specific
 */

const fs = require('fs');
const path = require('path');

const colors = {
  reset: '\x1b[0m',
  green: '\x1b[32m',
  yellow: '\x1b[33m',
  blue: '\x1b[34m',
  red: '\x1b[31m',
  cyan: '\x1b[36m',
  bold: '\x1b[1m',
  gray: '\x1b[90m'
};

function log(message, color = 'reset') {
  console.log(`${colors[color]}${message}${colors.reset}`);
}

// Load Tractatus instructions
const instructionPath = path.join(__dirname, '../.claude/instruction-history.json');
const data = JSON.parse(fs.readFileSync(instructionPath, 'utf8'));
const active = data.instructions.filter(i => i.active);

log('\n═'.repeat(80), 'cyan');
log('  Tractatus Instruction Applicability Analysis', 'bold');
log('  Target: family-history project (multi-tenant SaaS)', 'cyan');
log('═'.repeat(80), 'cyan');
log(`\nTotal active instructions: ${active.length}\n`, 'cyan');

// Categorization patterns
const categories = {
  alreadyApplicable: [],
  applicableButBlocked: [],
  notApplicable: []
};

// Keywords for classification
const blockedPatterns = [
  /ContextPressureMonitor/i,
  /BoundaryEnforcer/i,
  /MetacognitiveVerifier/i,
  /CrossReferenceValidator/i,
  /InstructionPersistenceClassifier/i,
  /PluralisticDeliberationOrchestrator/i,
  /instruction-history\.json/i,
  /audit.*log/i,
  /framework.*service/i,
  /session.*init/i,
  /token.*checkpoint/i,
  /pressure.*monitor/i,
  /\.claude\//i
];

const tractatusSpecific = [
  /port 9000/i,
  /port 27017/i,
  /tractatus/i,
  /agenticgovernance\.digital/i,
  /ago\.ovh/i,
  /glossary.*PDF/i,
  /blog.*post/i,
  /case.*submission/i,
  /\/docs\/markdown/i,
  /generate.*pdf/i,
  /family-history.*sydigital.*separate/i
];

// Classify each instruction
active.forEach(inst => {
  const text = inst.text.toLowerCase();

  // Check if Tractatus-specific
  if (tractatusSpecific.some(pattern => pattern.test(text))) {
    categories.notApplicable.push({
      ...inst,
      reason: 'Tractatus-specific (ports, domains, features)'
    });
    return;
  }

  // Check if blocked by framework dependency
  if (blockedPatterns.some(pattern => pattern.test(text))) {
    categories.applicableButBlocked.push({
      ...inst,
      reason: 'Requires framework services/infrastructure',
      blockers: blockedPatterns.filter(p => p.test(text)).map(p => p.source.slice(1, -2))
    });
    return;
  }

  // Check for multi-tenant conflicts
  if (/single.*tenant/i.test(text) || /no.*multi.*tenant/i.test(text)) {
    categories.notApplicable.push({
      ...inst,
      reason: 'Conflicts with family-history multi-tenant architecture'
    });
    return;
  }

  // Default to already applicable (general development practices)
  categories.alreadyApplicable.push({
    ...inst,
    reason: 'General development practice'
  });
});

// Display results
log('▶ Category 1: Already Applicable (Immediate Use)', 'green');
log(`  ${categories.alreadyApplicable.length} instructions can be used immediately\n`, 'green');

categories.alreadyApplicable.forEach((inst, idx) => {
  log(`  ${idx + 1}. ${inst.id} [${inst.quadrant}]`, 'cyan');
  log(`     ${inst.text.substring(0, 100)}...`, 'gray');
  log(`     ✓ ${inst.reason}`, 'green');
  console.log('');
});

log('\n▶ Category 2: Applicable but Blocked (Needs Framework)', 'yellow');
log(`  ${categories.applicableButBlocked.length} instructions require infrastructure\n`, 'yellow');

categories.applicableButBlocked.forEach((inst, idx) => {
  log(`  ${idx + 1}. ${inst.id} [${inst.quadrant}]`, 'cyan');
  log(`     ${inst.text.substring(0, 100)}...`, 'gray');
  log(`     ⚠ Blocked by: ${inst.blockers ? inst.blockers.join(', ') : inst.reason}`, 'yellow');
  console.log('');
});

log('\n▶ Category 3: Not Applicable (Tractatus-Specific)', 'red');
log(`  ${categories.notApplicable.length} instructions not relevant to family-history\n`, 'red');

categories.notApplicable.forEach((inst, idx) => {
  log(`  ${idx + 1}. ${inst.id} [${inst.quadrant}]`, 'cyan');
  log(`     ${inst.text.substring(0, 100)}...`, 'gray');
  log(`     ✗ ${inst.reason}`, 'red');
  console.log('');
});

// Summary statistics
log('\n═'.repeat(80), 'cyan');
log('  SUMMARY', 'bold');
log('═'.repeat(80), 'cyan');

const total = active.length;
const applicable = categories.alreadyApplicable.length;
const blocked = categories.applicableButBlocked.length;
const notApplicable = categories.notApplicable.length;

log(`\n  Total active instructions: ${total}`, 'cyan');
log(`    ✓ Already applicable: ${applicable} (${(applicable/total*100).toFixed(1)}%)`, 'green');
log(`    ⚠ Applicable but blocked: ${blocked} (${(blocked/total*100).toFixed(1)}%)`, 'yellow');
log(`    ✗ Not applicable: ${notApplicable} (${(notApplicable/total*100).toFixed(1)}%)`, 'red');

log(`\n  Implementation Strategy:`, 'bold');
log(`    1. Immediately adopt ${applicable} already-applicable rules`, 'green');
log(`    2. Install framework to unlock ${blocked} blocked rules`, 'yellow');
log(`    3. Ignore ${notApplicable} Tractatus-specific rules`, 'gray');

log(`\n  Framework Installation Unlocks: ${blocked} additional rules (${(blocked/total*100).toFixed(1)}% value increase)`, 'cyan');

log('\n═'.repeat(80), 'cyan');

// Export results
const output = {
  analysis_date: new Date().toISOString(),
  source: 'tractatus .claude/instruction-history.json',
  target: 'family-history project',
  total_instructions: total,
  categories: {
    already_applicable: {
      count: applicable,
      percentage: (applicable/total*100).toFixed(1),
      instructions: categories.alreadyApplicable.map(i => ({
        id: i.id,
        text: i.text,
        quadrant: i.quadrant,
        reason: i.reason
      }))
    },
    applicable_but_blocked: {
      count: blocked,
      percentage: (blocked/total*100).toFixed(1),
      instructions: categories.applicableButBlocked.map(i => ({
        id: i.id,
        text: i.text,
        quadrant: i.quadrant,
        reason: i.reason,
        blockers: i.blockers
      }))
    },
    not_applicable: {
      count: notApplicable,
      percentage: (notApplicable/total*100).toFixed(1),
      instructions: categories.notApplicable.map(i => ({
        id: i.id,
        text: i.text,
        quadrant: i.quadrant,
        reason: i.reason
      }))
    }
  }
};

const outputPath = path.join(__dirname, '../TRACTATUS_RULES_APPLICABILITY_ANALYSIS.json');
fs.writeFileSync(outputPath, JSON.stringify(output, null, 2));
log(`\n✓ Detailed analysis saved to: ${outputPath}`, 'green');
log('');