Plugin System

Keep the core small. Push complexity outward.

---

Overview

Rune core is intentionally language-agnostic.

It should not know anything about:

• Python
• TypeScript
• Java
• Rust
• Go

Language-specific intelligence belongs in plugins.

This keeps the Rune core:

• simple
• stable
• maintainable

---

Philosophy

Rune itself should understand:

Repository structure
Metadata
Dependency graphs
Context retrieval

Plugins should understand:

Syntax
Imports
Classes
Functions
Framework conventions

---

Architecture

                 Rune Core
                      │
        ┌─────────────┼─────────────┐
        │             │             │
rune-python   rune-typescript    rune-go
        │             │             │
     Python         TypeScript       Go

The core provides infrastructure.

Plugins provide language knowledge.

---

Why Plugins?

Without plugins, Rune core would eventually contain:

• AST parsers
• language grammars
• framework-specific logic

This would make the core:

• large
• difficult to maintain
• hard to extend

Plugins allow independent evolution.

---

Examples

Python

rune-python

Understands:

• imports
• classes
• functions
• decorators
• Django
• FastAPI

---

TypeScript

rune-typescript

Understands:

• modules
• interfaces
• React
• Next.js

---

Go

rune-go

Understands:

• packages
• interfaces
• structs
• methods

---

Rust

rune-rust

Understands:

• traits
• modules
• impl blocks

---

Java

rune-java

Understands:

• classes
• packages
• annotations

---

Plugin Responsibilities

Plugins are responsible for:

Parsing

Convert source files into structured representations.

Example:

from user import User

becomes:

{
  "imports": [
    "user"
  ]
}

---

Symbol Extraction

Identify:

• classes
• functions
• methods
• interfaces
• enums

---

Dependency Detection

Determine relationships between files.

Example:

auth.py
↓
user.py
↓
jwt.py

---

Summary Generation

Produce:

.rune/files/auth.md

Example:

Purpose:
Authentication service

Exports:
- login()
- logout()

Dependencies:
- user.py
- jwt.py

---

Feature Discovery

Detect feature boundaries.

Example:

login
signup
billing
subscription

and generate:

.rune/features/

---

Core Responsibilities

Rune core should provide:

CLI

rune init
rune index
rune update
rune context
rune doctor

---

Graph Engine

Produces:

graph.json

---

Context Engine

Answers:

Which files matter?

---

Repository Format

Maintains:

.rune/

---

Caching

Tracks:

• hashes
• timestamps

---

Plugin Discovery

Plugins are discovered automatically.

Example locations:

Linux:

~/.rune/plugins/

macOS:

~/.rune/plugins/

Windows:

%USERPROFILE%\.rune\plugins\

---

Example

Installed plugins:

~/.rune/plugins/

rune-python
rune-typescript
rune-go

Running:

rune index

might invoke:

rune-python
rune-typescript

depending on the repository contents.

---

Communication Model

Input:

{
  "file": "auth.py"
}

Output:

{
  "symbols": [
    "login",
    "logout"
  ],
  "dependencies": [
    "user.py",
    "jwt.py"
  ]
}

Communication should use:

• JSON
• stdin/stdout

No RPC servers are required.

---

Independence

Plugins should be versioned independently.

Example:

Rune Core      0.1.0
rune-python    0.4.0
rune-go        0.2.1

Core and plugins should evolve separately.

---

Framework Extensions

Plugins may support frameworks.

Examples:

Python:

• Django
• FastAPI
• Flask

TypeScript:

• React
• Next.js
• Express

Go:

• Gin
• Echo

Framework support should live inside plugins, not the core.

---

Failure Tolerance

If a plugin is missing:

rune-java

Rune should continue functioning.

Only Java analysis becomes unavailable.

The core should never crash because a plugin is absent.

---

Writing Plugins

A plugin should be:

• small
• standalone
• executable

Examples:

rune-python
rune-typescript
rune-rust
rune-java

Language is not restricted.

Plugins may be written in:

• Go
• Rust
• Python
• Java
• Node.js

as long as they expose the expected interface.

---

Non-Goals

Plugins should not:

• edit files
• call LLMs
• perform code generation
• access remote APIs

Plugins provide understanding.

Agents provide intelligence.

---

Design Principles

Prefer:

• standalone binaries
• JSON
• stdin/stdout
• independent releases

Avoid:

• shared memory
• databases
• daemon processes
• tightly coupled integrations

---

Philosophy

Rune should know as little as possible.

Plugins should know everything about their language.

Git stores history.

Rune stores understanding.