Skip to content

For Windsurf users

Windsurf edits the file.
Maguyva sees the repo.

Windsurf is the editor and Cascade is the agent. In a monorepo, the agent still needs a map of which file matters. Maguyva indexes your codebase and serves it back over MCP (semantic, AST, graph, and text), so “where does auth happen” returns the actual auth flow, not seven test stubs.

Index your first repo Read the Windsurf setup

Public beta. Free tier: 3 repos, 50K indexed lines, no card.

Windsurf edits what you point at. Maguyva tells Cascade which file to point at.

What each layer does

Four pieces. Each one has a job.

// editor

Windsurf

Where you and Cascade actually work.

// manual context

@ mentions + .windsurfrules

Manual context wins, until the repo is big.

// codebase

Maguyva

Automatic codebase facts over MCP.

// who pays

Workspaces, not seats

Agents don’t pay seats. See pricing

Windsurf is the editor. Use it.

The IDE is not the problem. Cascade, tab completion, multi-file edits, and .windsurfrules are excellent, and you already use them for:

  • Inline suggestions and Cascade edits in the open file.
  • Multi-file edits when the change is local.
  • .windsurfrules for repo conventions and style guardrails.
  • @-mentions to pull a specific file into context.

Keep doing that. None of it goes away.

But in a real monorepo (TypeScript with workspace deps, Python services, mixed packages) agent context breaks the moment the relevant file isn’t already on Cascade’s radar.

Manual fixes you’ve already tried, and where they break

Four manual fixes paired with their failure mode. Left = what you do today. Right = where it breaks.

// the fix

// mention the files

You @-mention the three files you think matter. Cascade edits cleanly inside them.

// where it breaks

// mentioning is a guess

It works when you already know which files are involved. The whole point of context tools is to surface the files you didn’t know to mention.

// the fix

// paste the snippets

You paste 200 lines from another package into Cascade to give it enough context.

// where it breaks

// pasted code goes stale

The snippet you pasted at 9 a.m. doesn’t reflect the rebase your teammate landed at 11 a.m. Cascade is editing against a phantom version of the package.

// the fix

// write a context doc

You write a .windsurfrules file or an architecture markdown. It’s right today.

// where it breaks

// docs drift faster than code

Anything you write by hand drifts. The code is the source of truth. A doc explaining the queue layer is correct for a week, then wrong forever.

// the fix

// keep the rules files

You add .windsurfrules for naming, lint, and build commands. Great for behavior.

// where it breaks

// rules ≠ index

.windsurfrules is the right place for “always run pnpm tsc -b before commits.” It is not a queryable index of every symbol, file, and call-site in your monorepo.

Maguyva is the layer underneath

Not a Windsurf replacement. The repo-context layer that hangs off Cascade’s MCP support.

  • Semantic + AST + graph + text search by meaning, structure, dependency, or literal. Every hit returns a file path and line number.
  • Cross-package by default call-sites and importers across every package in the monorepo, not just the one Cascade has open.
  • Branch-aware Maguyva sees the version of the code Cascade is editing.
  • Complementary, not competitive .windsurfrules keeps doing its job. @-mentions keep doing theirs. Maguyva fills the gap they don’t fill.

Cascade edits the file you point at.

Maguyva tells the agent which file to point at.

Three monorepo workflows

Cross-package, cross-language. Grounded against the actual call graph, not Cascade’s grep.

// workflow 01

Find the auth flow across packages, without mentioning anything

cascade> where does authentication happen in this monorepo?

graph::query("authentication flow")
  packages/web/src/auth/session.ts:42       middleware
  packages/api/src/auth/jwt.ts:88           token verify
  packages/shared/src/auth/types.ts:12      AuthContext
  packages/admin/src/auth/admin-only.ts:31  rbac gate

→ 4 entry points across 4 packages, ranked by call-site density.
[exit 0]

You didn’t mention a file. You didn’t paste a snippet. Cascade has the four files that matter, in the right ranking, and can make a grounded edit.

// workflow 02

Find the real implementation, not the test stub

cascade> how does normalizePhoneNumber handle E.164?

semantic::query("normalize phone E.164")
  packages/shared/util/phone.ts:88     normalizePhoneNumber()  ← real impl
  packages/api/test/phone.spec.ts:14   jest.mock(...)          ← stub
[exit 0]

Names lie. Mocks shadow real code. Maguyva ranks the real implementation above the test mock, across every package.

// workflow 03

Check blast radius before you refactor

cascade> what calls QueueDispatcher.publish across the monorepo?

graph::callers(QueueDispatcher.publish)
  3 in packages/billing/*
  1 in packages/audit/*
  1 in packages/notifications/*
  1 in services/python-worker/*  ← cross-language via gRPC stub
[exit 0]

Cross-package, and cross-language when you have a polyglot repo, call-sites surface inline. The diff is grounded against real importers, not Cascade’s grep.

Setup with Windsurf

Three steps. Free tier: 3 repos, 50K indexed lines, no card.

  1. // step 01

    Index a repo at maguyva.ai

    Pick the monorepo where you’ve felt the most context pain.

  2. // step 02

    Add Maguyva as an MCP server in Windsurf

    // ~/.codeium/windsurf/mcp_config.json
{
  "mcpServers": {
    "maguyva": {
      "serverUrl": "https://maguyva.tools/mcp",
      "headers": {
        "Authorization": "Bearer <your-key>"
      }
    }
  }
}

  3. // step 03

    Ask one question whose answer you already know

    Don’t start with your whole company. Start with one repo and one verifiable question, like “what calls formatInvoice across packages?”

Public beta. Self-serve signups open.

Index one repo you already know.

Test one question whose answer you can verify.

Get a beta spot See compatibility docs

free plan: 3 repos, 50K indexed lines, no card.