Skip to content

Home

Jump to bottom
ChesterHsu edited this page Feb 12, 2026 · 2 revisions

Welcome to the flyto-indexer wiki!

flyto-indexer — Code index for AI assistants

A code indexing tool that gives AI assistants some structural awareness of your codebase. That's it — nothing fancy.

What this actually does

AI coding assistants are good at writing code, but they don't really "see" your project. They don't know that renaming a function will break 5 files, or that a composable is used across 3 projects.

flyto-indexer fills that gap. It scans your code, builds a symbol index, and exposes it through 23 MCP tools that any AI client can call. Think of it as a lookup table for your codebase — the AI asks questions, the index answers.

It's a helper, not a replacement for anything. It doesn't write code, doesn't make decisions, doesn't do anything clever. It just indexes and answers queries.

Quick numbers

What How much
MCP tools 23
Languages 6 (Python, TypeScript/JS, Vue, Go, Rust, Java)
Tests 840
Dependencies None for core (pure Python stdlib)

What the tools do

The tools roughly fall into a few categories:

Finding things — search_code, get_symbol_content, get_file_symbols, fulltext_search, get_file_context, get_file_info

These let the AI search for functions, classes, and components by name or keyword. search_code uses BM25 ranking (the same basic algorithm behind Elasticsearch) so results are ordered by relevance rather than just string matching.

Understanding impact — impact_analysis, find_references, dependency_graph, edit_impact_preview, cross_project_impact

The main use case. Before the AI changes something, it can check what depends on it. impact_analysis returns the list of affected files and a rough risk level. Nothing magical — it's just walking the dependency graph.

Project overview — list_projects, list_categories, list_apis, check_index_status

High-level stuff. list_apis is interesting — it links Python backend endpoints (FastAPI/Flask decorators) to frontend callers (fetch/axios in TypeScript/Vue). Useful for full-stack projects.

Code quality — find_dead_code, find_todos

find_dead_code finds functions and components that nothing references. Not perfect (static analysis can't catch dynamic imports or metaprogramming), but catches the obvious cases.

Housekeeping — check_and_reindex, session_track, session_get, find_test_file, get_description, update_description

Index maintenance and session-based search boosting. check_and_reindex can do live incremental reindex without restarting the MCP server.

How it works

your-project/
├── src/             ← Your code
└── .flyto-index/    ← Generated index
    ├── index.json       Symbols, dependencies, reverse index
    ├── content.jsonl    Source code (lazy-loaded)
    ├── bm25.json        Search index
    └── manifest.json    Content hashes for incremental updates
  1. AST parsers extract symbols (functions, classes, components) from your code
  2. Dependencies are resolved — imports, function calls, API calls across languages
  3. A reverse index is built (symbol → who references it)
  4. The MCP server exposes all of this through JSON-RPC

Incremental updates only re-scan changed files (tracked via content hashes), so re-indexing after a few edits is fast.

Supported languages

Language How it parses What it extracts
Python ast module Functions, classes, methods, decorators, API endpoints
TypeScript/JS Regex-based Functions, classes, interfaces, types, exports, API calls
Vue SFC parser Components, composables, props, emits, API calls
Go Regex-based Functions, structs, methods, interfaces
Rust Regex-based Functions, structs, impl blocks, traits
Java Regex-based Classes, methods, interfaces, annotations

Python gets the best coverage since we use the real AST. The regex-based parsers work well for typical code but won't catch every edge case.

Limitations

Worth being upfront about:

  • Static analysis only. Dynamic imports, getattr(), eval(), runtime code generation — none of that is tracked.
  • No type inference. Complex TypeScript generics and conditional types are simplified.
  • Regex parsers aren't perfect. Unusual formatting or deeply nested code can trip up the TS/Go/Rust/Java scanners.
  • Cross-project tracking requires all projects to be indexed together in the same .flyto-index.
  • Not a replacement for LSP. If your editor has a language server running, that's going to be more accurate for single-file operations. This tool is more useful for cross-file and cross-project questions.

Getting started

The README has setup instructions. The short version:

pip install flyto-indexer
flyto-index scan /path/to/your/project

Then add the MCP server to your AI client's config. Works with Claude Code, Cursor, Windsurf, or anything that speaks MCP.

Pages

Clone this wiki locally