AIED - AI Terminal Editor

A terminal-based text editor inspired by VIM with integrated AI capabilities. AIED combines the efficiency and power of modal editing with modern AI assistance for developers.

What This Skill Does

This skill helps you work with the AIED codebase - a Go-based terminal editor that provides VIM-style modal editing with integrated AI capabilities. The project implements essential VIM features including buffer management, terminal UI, mode system, and command execution.

Core Features

Architecture

Completed Components

The following components are production-ready with comprehensive test coverage:

1. **Buffer System** (`internal/buffer/`)

- Line-based text storage with cursor management

- Character and line operations (insert, delete, backspace)

- File I/O with error handling

- 75.2% test coverage

2. **Terminal UI** (`internal/ui/`)

- tcell-based terminal interface

- Screen rendering and keyboard input processing

- Viewport scrolling and status line

- Mode-aware rendering and command line display

3. **VIM Modes System** (`internal/modes/`)

- Complete modal editing (Normal, Insert, Visual, Command)

- Mode manager with seamless transitions

- VIM-compatible navigation (hjkl, word movement, line operations)

- Mode-specific key bindings

4. **VIM Command System** (`internal/commands/`)

- Ex-command implementation with Command mode

- File commands: `:w`, `:q`, `:wq`, `:q!`

- Editor commands: `:e`, `:new`

- Command parsing, execution, and registry

Project Structure

```

aied/

├── main.go # Entry point with complete VIM editor

├── internal/ # Private application code

│ ├── buffer/ # ✅ Text buffer management

│ ├── ui/ # ✅ Terminal UI components

│ ├── modes/ # ✅ VIM mode implementations

│ ├── commands/ # ✅ VIM command system

│ ├── editor/ # Core editor logic

│ └── ai/ # AI integration layer

├── pkg/ # Public packages

│ ├── config/ # Configuration handling

│ └── plugin/ # Plugin API

└── go.mod # Go module file

```

Instructions for AI Agent

When working with the AIED codebase, follow these steps:

1. Understanding the Codebase

2. Development Workflow

**Building:**

```bash

go build # Build the aied binary

go build -o aied # Build with specific output name

go install # Install to $GOPATH/bin

```

**Testing:**

```bash

go test ./... # Run all tests

go test -v ./... # Run with verbose output

go test -cover ./... # Run with coverage report

```

**Running:**

```bash

go run main.go # Run the editor directly

go fmt ./... # Format all Go files

go vet ./... # Run static analysis

golangci-lint run # Run comprehensive linting (if installed)

```

3. Making Changes

**For Bug Fixes:**

**For New Features:**

**For Refactoring:**

4. Code Quality Standards

5. VIM Compatibility

When implementing VIM-related features:

6. AI Integration

The AI integration layer (`internal/ai/`) is planned but not yet implemented. When working on AI features:

7. Technical Stack Preferences

Important Constraints

Example Usage

**Navigating the codebase:**

```bash

Explore buffer implementation

cat internal/buffer/buffer.go

cat internal/buffer/buffer_test.go

Check mode system

cat internal/modes/manager.go

cat internal/modes/normal.go

Review command system

cat internal/commands/registry.go

```

**Making a change:**

```bash

1. Run tests to establish baseline

go test ./...

2. Make changes to relevant files

(edit files in internal/buffer/, internal/ui/, etc.)

3. Run tests to verify

go test ./... -v

4. Format and lint

go fmt ./...

go vet ./...

5. Build and manually test

go build && ./aied testfile.txt

```