Your Codebase Is a Graph, Not Files — Why That Changes Everything

@Service
public class ProjectService {
    @Autowired
    private ProjectRepository projectRepository;
    
    public Project createProject(CreateProjectRequest request) {
        // ... implementation
    }
    
    @Transactional
    public void deleteProject(Long projectId) {
        // ... implementation
    }
}

// Real code from our Node.js indexer
async function extractSymbols(filePath: string, content: string): Promise<Symbol[]> {
  const sourceFile = ts.createSourceFile(
    filePath,
    content,
    ts.ScriptTarget.Latest,
    true
  );
  
  const symbols: Symbol[] = [];
  
  function visit(node: ts.Node) {
    if (ts.isClassDeclaration(node)) {
      symbols.push({
        name: node.name?.text || '<anonymous>',
        type: 'class',
        line: getLineNumber(sourceFile, node.pos),
        // ... more metadata
      });
    }
    
    if (ts.isMethodDeclaration(node)) {
      symbols.push({
        name: node.name.getText(sourceFile),
        type: 'method',
        parentSymbol: getCurrentClass(),
        // ... method details
      });
    }
    
    ts.forEachChild(node, visit);
  }
  
  visit(sourceFile);
  return symbols;
}

-- Our actual database schema for call relationships
CREATE TABLE symbol_calls (
    id SERIAL PRIMARY KEY,
    workspace_id INTEGER NOT NULL,
    caller_symbol_id INTEGER NOT NULL,
    called_symbol_id INTEGER NOT NULL,
    call_type VARCHAR(50) NOT NULL, -- 'direct', 'interface', 'async'
    line_number INTEGER,
    FOREIGN KEY (caller_symbol_id) REFERENCES symbols(id),
    FOREIGN KEY (called_symbol_id) REFERENCES symbols(id)
);

@RestController
@RequestMapping("/api/projects")
public class ProjectController {
    
    @PostMapping
    public ResponseEntity<Project> createProject(@RequestBody CreateProjectRequest request) {
        // This becomes a discovered route: POST /api/projects
    }
}

// Frontend code
const response = await fetch('/api/projects', {
  method: 'POST',
  body: JSON.stringify(projectData)
});

-- Real query from our route matching logic
INSERT INTO cross_language_calls (frontend_file_id, backend_route_id, http_method, path)
SELECT f.id, r.id, 'POST', '/api/projects'
FROM code_files f, web_routes r
WHERE f.content LIKE '%/api/projects%'
  AND r.path = '/api/projects'
  AND r.http_method = 'POST';

# Simplified version of our clustering algorithm
def discover_features(call_graph):
    # Build NetworkX graph from symbol calls
    G = nx.Graph()
    for call in symbol_calls:
        G.add_edge(call.caller_file, call.called_file, weight=call.frequency)
    
    # Run community detection
    communities = nx.community.louvain_communities(G, resolution=1.2)
    
    features = []
    for community in communities:
        if len(community) < 3:  # Skip tiny clusters
            continue
            
        feature = {
            'name': generate_feature_name(community),
            'files': list(community),
            'confidence': calculate_confidence(community, G)
        }
        features.append(feature)
    
    return features

// Real MCP tool from our system
async function getSymbolCallGraph(symbolName: string, depth: number = 2) {
  const query = `
    WITH RECURSIVE call_tree AS (
      SELECT s.id, s.name, s.type, 0 as depth
      FROM symbols s 
      WHERE s.name = $1
      
      UNION ALL
      
      SELECT s.id, s.name, s.type, ct.depth + 1
      FROM symbols s
      JOIN symbol_calls sc ON s.id = sc.called_symbol_id
      JOIN call_tree ct ON sc.caller_symbol_id = ct.id
      WHERE ct.depth < $2
    )
    SELECT * FROM call_tree;
  `;
  
  return await db.query(query, [symbolName, depth]);
}

-- Traditional approach
CREATE TABLE files (
    id SERIAL PRIMARY KEY,
    path TEXT,
    content TEXT
);

-- Our approach  
CREATE TABLE symbols (
    id SERIAL PRIMARY KEY,
    name VARCHAR(255),
    type VARCHAR(50),
    file_id INTEGER,
    -- symbols are first-class, files are storage
);

CREATE TABLE code_files (
    id SERIAL PRIMARY KEY,
    file_path TEXT,
    content TEXT
    -- files exist to hold symbols
);

-- Every table includes workspace_id for isolation
CREATE TABLE symbols (
    id SERIAL PRIMARY KEY,
    workspace_id INTEGER NOT NULL,
    name VARCHAR(255),
    type VARCHAR(50),
    -- ... other fields
);

CREATE INDEX idx_symbols_workspace_name ON symbols(workspace_id, name);

Your Codebase Is a Graph, Not Files — Why That Changes Everything

The File Delusion

Related Posts

Best GPT for Coding: Comparing AI Code Assistants

Symbols Are Your Real Building Blocks

Building the Graph

Cross-Language Graph Construction

Feature Discovery Through Graph Analysis

Graph-Based Code Intelligence

The Database Schema Reality

Multi-Workspace Graph Isolation

Why This Matters

The Future Is Graph-Native

JavaScript Static Code Analysis Beyond ESLint

Code Refactoring Tools: When to Automate vs Manual