# Enesis Editor

A high-performance **block markdown editor** built with Vue 3, TypeScript, ProseMirror, and the Lezer parsing framework.

Documents are structured as distinct, interactive **Blocks** rather than a single flat string. A 3-stage parsing pipeline bridges UI state down to ASTs, enabling real-time extraction of pages, references, task state, callouts, and inline decorations.

## Monorepo Structure

```
├── apps/
│   └── dev/                  Development sandbox (Vue 3 + Vite)
│       ├── src/
│       │   ├── components/
│       │   │   ├── Editor.vue          Main playground
│       │   │   └── AppLogo.vue         Enesis brand mark
│       │   ├── pages/
│       │   │   └── EditorView.vue      Route page
│       │   ├── App.vue                 Shell layout (Nuxt UI)
│       │   ├── main.ts                 App bootstrap
│       │   └── style.css               Tailwind v4 + Nuxt UI theme
│       ├── public/                     Static assets
│       └── vite.config.ts              Vite with Nuxt UI plugin
│
├── packages/
│   └── editor/                Core headless engine
│       ├── src/
│       │   ├── index.ts               Public API (Block component + plugin)
│       │   ├── components/
│       │   │   └── Block.vue           Self-contained ProseMirror block editor
│       │   ├── composables/
│       │   │   ├── useMarkdownDecorations.ts   ProseMirror decoration plugin
│       │   │   ├── useBlockKeyboardHandlers.ts Keyboard handler (Enter, Backspace, arrows)
│       │   │   └── usePatternPlugin.ts         Pattern detection ([[, ((, /, #)
│       │   └── lib/
│       │       ├── markdown-parser.ts          Lezer parser configuration
│       │       ├── markdown-extensions.ts      Custom Lezer extensions
│       │       ├── content-model.ts            Markdown ↔ ProseMirror conversion
│       │       ├── schema.ts                   Minimal ProseMirror schema
│       │       └── markdown-rules/
│       │           ├── engine.ts               MarkdownRuleEngine (3-stage pipeline)
│       │           ├── types.ts                Shared type interfaces
│       │           ├── inline-rules.ts         Inline syntax rules
│       │           ├── block-rules.ts          Block syntax rules
│       │           └── block-classifier.ts     First-line regex classifier
│       ├── vite.config.ts            Library build (ESM, tailwind, vue)
│       └── vitest.config.ts          Test runner configuration
│
├── .forgejo/
│   └── workflows/
│       └── deploy.yml               CI: build + deploy to Codeberg Pages
│
├── package.json                    Workspace root
├── pnpm-workspace.yaml            pnpm workspace definition
├── AGENTS.md                      Project conventions for AI coding agents
└── biome.json                     Linting & formatting
```

## Quick Start

```bash
pnpm install
pnpm dev            # Start the dev sandbox at localhost:5173
pnpm test           # Run editor unit tests (Vitest)
pnpm check          # Lint & format check (Biome)
```

## Scripts

| Script | Description |
|---|---|
| `pnpm dev` | Start Vite dev server for `@enesis/dev` sandbox |
| `pnpm build` | Build `@enesis/editor` library (ESM + type declarations) |
| `pnpm test` | Run unit tests for `@enesis/editor` |
| `pnpm check` | Run Biome lint & format check across the workspace |

## Deployment

On push to `master`, a Forgejo Actions workflow builds the dev app and deploys it to **Codeberg Pages** at `https://enesismd.codeberg.page/editor/`.

## Technology

| Layer | Technology |
|---|---|
| Framework | Vue 3 (Composition API, `<script setup>`) |
| Editor Engine | ProseMirror (view, state, model, transform, keymap, gapcursor) |
| Parsing | Lezer (`@lezer/markdown` + GFM + custom extensions) |
| Styling | Tailwind CSS v4 + Nuxt UI v4 |
| Type Safety | TypeScript (`strict: true`) |
| Testing | Vitest with jsdom |
| Formatting | Biome |
| Package Manager | pnpm workspaces |
| CI/CD | Forgejo Actions → Codeberg Pages |

## License

MIT