get_network_analysis

Instructions

Implementation Reference

• src/analytics.ts:7-22 (handler)

  Main handler function implementing the get_network_analysis tool logic. Fetches board interlocks, shareholder data, computes network metrics, and generates governance risk factors.

  async getComplexNetworkAnalysis(): Promise<any> {
    const companies = await this.db.getAllCompanies();
    const directors = await this.db.getBoardInterlocks();
    const shareholders = await this.db.getShareholderOverlap();
  
    // Calculate network metrics
    const directorNetworkMetrics = this.calculateDirectorNetworkMetrics(directors);
    const shareholderNetworkMetrics = this.calculateShareholderNetworkMetrics(shareholders);
  
    return {
      director_network: directorNetworkMetrics,
      shareholder_network: shareholderNetworkMetrics,
      cross_ownership_analysis: shareholders,
      governance_risk_factors: await this.getGovernanceRiskFactors(companies, directors)
    };
  }

• src/index.ts:337-344 (schema)

  Tool schema definition including name, description, and empty input schema for get_network_analysis.

  {
    name: 'get_network_analysis',
    description: 'Get comprehensive network analysis of board interlocks and shareholder relationships',
    inputSchema: {
      type: 'object',
      properties: {},
    },
  },

• src/index.ts:649-651 (registration)

  Tool registration in the CallToolRequestSchema switch statement, dispatching to the analytics handler.

  case 'get_network_analysis':
    result = await this.analytics.getComplexNetworkAnalysis();
    break;

• src/analytics.ts:24-43 (helper)

  Helper function to calculate director network metrics from interlocks data.

  private calculateDirectorNetworkMetrics(interlocks: any[]): any {
    // Analyze existing interlock data
    const totalInterlocks = interlocks.length;
    const topDirectors = interlocks.slice(0, 10);
    
    // Calculate sector distribution
    const sectorConnections = new Map();
    interlocks.forEach(interlock => {
      const companies = interlock.companies.split(',');
      // Note: We'd need sector information to do proper sector analysis
      // This is simplified for the API-based approach
    });
  
    return {
      total_interlocks: totalInterlocks,
      interlocked_directors: topDirectors,
      most_connected_directors: topDirectors.slice(0, 5),
      network_density: totalInterlocks > 0 ? totalInterlocks / 35 : 0 // IBEX 35 companies
    };
  }

• src/analytics.ts:58-96 (helper)

  Helper function to compute governance risk factors based on interlocks and company data.

  private async getGovernanceRiskFactors(companies: any[], interlocks: any[]): Promise<any> {
    // Analyze companies for governance red flags
    const redFlags: any[] = [];
  
    companies.forEach(company => {
      // Check for high director interlocks
      const companyInterlocks = interlocks.filter(interlock => 
        interlock.companies.includes(company.symbol)
      );
  
      if (companyInterlocks.length > 3) {
        redFlags.push({
          company: company.symbol,
          risk_type: 'high_director_interlocks',
          description: `Company has ${companyInterlocks.length} interlocked directors`,
          severity: 'medium'
        });
      }
  
      // Check market cap for concentration risk
      if (company.market_cap && company.market_cap > 50000000000) { // 50B EUR
        redFlags.push({
          company: company.symbol,
          risk_type: 'market_dominance',
          description: `Large market cap may indicate market concentration`,
          severity: 'low'
        });
      }
    });
  
    return {
      governance_red_flags: redFlags.sort((a, b) => 
        (b.severity === 'high' ? 3 : b.severity === 'medium' ? 2 : 1) - 
        (a.severity === 'high' ? 3 : a.severity === 'medium' ? 2 : 1)
      ),
      total_red_flags: redFlags.length,
      high_risk_companies: redFlags.filter(f => f.severity === 'high').length
    };
  }