How the GitNexus Entry Point Scoring Algorithm Identifies Application Entry Points

The GitNexus entry point scoring algorithm ranks every function by combining a call-ratio base score with multipliers for export visibility, naming conventions, and framework-specific directory hints to surface the most probable application entry points.

GitNexus uses a sophisticated entry point scoring algorithm to automatically identify where a codebase begins execution. Located in gitnexus/src/core/ingestion/entry-point-scoring.ts, this system evaluates every function and method across four orthogonal signals to distinguish true entry points—such as request handlers, UI hooks, and CLI commands—from internal utility functions.

How the Entry Point Scoring Algorithm Works

The entry point scoring algorithm combines four distinct heuristics into a composite score. Each heuristic captures a different signal that distinguishes entry points from helper functions.

1. Call-Ratio Base Score

The foundation of the score is the call ratio, which measures how many functions a symbol calls versus how many call it. Entry points typically orchestrate many downstream calls while receiving few upstream calls.

The algorithm calculates this as:

baseScore = calleeCount / (callerCount + 1)

Functions with zero calleeCount are immediately discarded and receive a score of 0, as they cannot initiate any forward traversal of the call graph.

2. Export Visibility Multiplier

Exported or public symbols are more likely to serve as entry points because they are designed to be reachable from outside their module. The algorithm checks the isExported flag:

• Exported: exportMultiplier = 2.0
• Internal: exportMultiplier = 1.0

3. Name-Pattern Matching

Naming conventions provide strong signals about a function's role. GitNexus maintains two pattern tables in entry-point-scoring.ts:

• ENTRY_POINT_PATTERNS: Positive regexes matching names like handleLogin, onSubmit, main, or viewDidLoad. Match → nameMultiplier = 1.5.
• UTILITY_PATTERNS: Negative regexes matching helpers like getUser, isValid, hasPermission, or leading underscores. Match → nameMultiplier = 0.3 (strong penalty).

4. Framework Directory Hints

Certain frameworks place entry points in characteristic directories. The helper detectFrameworkFromPath (imported from framework-detection.ts) analyzes file paths for patterns like:

• pages/ → Next.js
• routes/ → Express
• views/ → Django

When a framework is detected, the algorithm applies a frameworkMultiplier specific to that framework's entry point conventions.

The Complete Scoring Formula

The calculateEntryPointScore function combines these factors into the final entry point score:

finalScore = baseScore × exportMultiplier × nameMultiplier × frameworkMultiplier

This multiplicative approach ensures that functions must satisfy multiple criteria to achieve high scores. A function with a strong call ratio but a utility name (like getUser) will be penalized by the 0.3 name multiplier, while an exported handleRequest function in an Express routes/ directory benefits from all positive multipliers.

Implementation Walkthrough

The entry point scoring algorithm is implemented in gitnexus/src/core/ingestion/entry-point-scoring.ts. Here is how the key components work:

Pattern Definitions

Lines 23-84 define the regex patterns used for name matching. The ENTRY_POINT_PATTERNS map contains language-specific arrays of RegExp objects, while UTILITY_PATTERNS holds global negative patterns that apply across all languages (lines 56-71).

The calculateEntryPointScore Function

This is the main entry point for the algorithm (lines 10-61):

1. Early Exit: Lines 10-13 check if calleeCount === 0 and return 0 immediately.
2. Base Score Calculation: Lines 15-18 compute the call ratio.
3. Export Check: Lines 20-24 apply the export multiplier.
4. Name Pattern Logic: Lines 26-43 iterate through patterns to determine the name multiplier.
5. Framework Detection: Lines 45-53 call detectFrameworkFromPath to get the framework multiplier.
6. Final Computation: Lines 55-61 multiply all factors and return the score with diagnostic reasons.

Filtering Helpers

The file also contains isTestFile (lines 68-86) and isUtilityFile (lines 89-103) helpers. These functions identify test files (.test.ts, .spec.js, etc.) and utility directories (utils/, helpers/) so the ingestion pipeline can exclude them from scoring entirely.

Code Examples

Here is how to use the entry point scoring algorithm in practice:

Scoring an Express Route Handler

import {
  calculateEntryPointScore,
} from './entry-point-scoring.js';

// Analyzing a typical Express authentication handler
const name = 'handleLogin';
const language = 'typescript';
const isExported = true;          // exported from module
const callers = 2;                // called by router and middleware
const callees = 5;                // calls database, logger, validator, etc.
const filePath = 'src/routes/auth.ts';

const { score, reasons } = calculateEntryPointScore(
  name,
  language,
  isExported,
  callers,
  callees,
  filePath,
);

console.log(`Score: ${score.toFixed(2)}`, reasons);
// → Score: 7.50 [ 'base:5.00', 'exported', 'entry-pattern', 'framework:express' ]

Filtering Test Files

import { isTestFile } from './entry-point-scoring.js';

// Exclude test files from entry point detection
if (isTestFile(filePath)) {
  // Skip – tests are never considered entry points
  return;
}

Key Files in the Architecture

The entry point scoring algorithm spans several modules in the GitNexus codebase:

File	Role
gitnexus/src/core/ingestion/entry-point-scoring.ts	Core implementation of the scoring algorithm, pattern definitions, and filtering helpers.
gitnexus/src/core/ingestion/framework-detection.ts	Provides detectFrameworkFromPath for framework-specific multipliers.
gitnexus/src/core/ingestion/process-processor.ts	Orchestrates the ingestion pipeline, invoking calculateEntryPointScore for every symbol and selecting top candidates.
gitnexus/test/unit/entry-point-scoring.test.ts	Unit tests validating scoring outcomes across different languages and patterns.

Summary

• The entry point scoring algorithm in GitNexus ranks functions using a multiplicative formula that combines call-ratio, export status, naming patterns, and framework hints.
• The base score derives from the callee-to-caller ratio, immediately filtering out functions with no outgoing calls.
• Export multipliers (2.0×) boost public symbols, while name-pattern multipliers reward entry-point conventions (1.5×) or penalize utility prefixes (0.3×).
• Framework detection applies additional multipliers based on characteristic directory structures like routes/ or pages/.
• The implementation resides in gitnexus/src/core/ingestion/entry-point-scoring.ts, with supporting logic in framework-detection.ts and process-processor.ts.

Frequently Asked Questions

What makes the entry point scoring algorithm in GitNexus language-agnostic?

The algorithm relies on universal signals—call graph topology, export visibility, and naming patterns—rather than language-specific AST parsing. While ENTRY_POINT_PATTERNS contains per-language regexes (e.g., /^use[A-Z]/ for React hooks, /^main$/ for C), the core scoring logic in calculateEntryPointScore treats these patterns as generic multipliers, allowing the same formula to work across TypeScript, Python, Java, and other supported languages.

How does GitNexus avoid scoring internal utility functions as entry points?

GitNexus employs multiple defensive strategies. First, the utility pattern penalty (UTILITY_PATTERNS) applies a 0.3× multiplier to names matching prefixes like get, set, is, has, or leading underscores. Second, the isUtilityFile helper identifies files in utils/ or helpers/ directories and excludes them from scoring. Finally, functions with zero outgoing calls are automatically discarded, eliminating pure data-access helpers that never orchestrate downstream logic.

Can the entry point scoring algorithm detect framework-specific entry points like Next.js pages?

Yes, framework detection is a core component of the scoring system. The detectFrameworkFromPath function (imported from framework-detection.ts) analyzes file paths for characteristic directories. For example, files under pages/ trigger the Next.js detector and apply a framework-specific multiplier, while routes/ signals Express, and views/ indicates Django. These multipliers adjust the final score to reflect the higher probability that files in these locations serve as application entry points according to framework conventions.

Where is the entry point scoring logic invoked in the GitNexus pipeline?

The scoring logic is invoked by the process processor located at gitnexus/src/core/ingestion/process-processor.ts. During the ingestion phase, this processor iterates over every discovered symbol in the codebase and calls calculateEntryPointScore with the symbol's metadata—including name, language, export status, caller/callee counts, and file path. It then ranks all symbols by their returned scores and selects the top candidates as the official entry points for the repository, storing the diagnostic reasons array for UI explanation and debugging purposes.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}