Roadmap

Maina is open source (Apache 2.0) and actively developed. Here is what is shipped and planned.

Shipped (v1.0.0)

Maina v1.0.0 launched under the @mainahq organization. Everything below shipped across v0.3.0 through v1.0.0.

Core (v0.3.x)

• 38+ CLI commands including maina brainstorm as the workflow starting point
• 19+ tool verification pipeline — Biome, ruff, go vet, clippy, dotnet format, Checkstyle, PHPStan, Semgrep, Trivy, Secretlint, SonarQube, Stryker, diff-cover, AI review, slop detection, visual regression, typecheck, consistency check, ZAP, Lighthouse
• 7 languages — TypeScript, Python, Go, Rust, C#/.NET, Java/Kotlin, PHP
• Structured AI delegation — ---MAINA_AI_REQUEST--- stdout protocol for any MCP-compatible host
• Visual verification — Playwright screenshot regression testing
• Workflow context — rolling summary forwarded between lifecycle steps
• Background RL — async feedback recording at each workflow step with post-workflow analysis
• Verification proof — maina pr includes verification artifacts in the PR body
• maina brainstorm — interactive idea exploration that generates structured GitHub issues
• maina configure — interactive constitution, conventions, tools, visual URLs
• maina init --install — auto-install missing verification tools + auto-configure Biome
• --json flag on 8 commands (analyze, commit, context, doctor, review, slop, stats, verify) for machine-readable output
• Exit codes — 0 (passed), 1 (findings), 2 (tool failure), 3 (config error)
• --auto flags for maina spec and maina design — CI and scripting workflows
• Post-workflow RL trace analysis — Proposes prompt improvements fed into maina learn
• 10 MCP tools for IDE integration
• 8 cross-platform skills for Claude Code, Cursor, Windsurf, Cline, Roo Code, Continue.dev, Codex, Gemini CLI, Amazon Q, Zed, Aider

Cloud + Team (v0.5.0–v0.6.0)

• Maina Cloud API — Workers service using @workkit packages
• maina login/logout — GitHub OAuth device flow
• maina sync push/pull — Shared prompts + feedback across team members
• maina team — Team management and invites
• maina verify --cloud — Submit diffs to Maina Cloud for hosted verification
• Proof artifacts in R2 — @workkit/r2 for verification results
• Distributed cache — Content-hash cache on KV with SWR
• A/B test coordination — Durable Objects track prompt variant allocation
• PR check integration — Maina runs as a GitHub PR check alongside Copilot, CodeRabbit, DeepSource. Adds the verification-first layer they’re missing: spec compliance, cross-function consistency, slop detection, AI review with learned prompts. Posts inline review comments on findings.
• mainahq/maina/.github/actions/verify@main — GitHub Action for CI integration in 3 lines of YAML
• mainahq/workflow-action — Autonomous coding Action — A GitHub Issue triggers the full maina workflow (brainstorm → plan → design → spec → implement → verify → review → commit → PR). User writes an issue, Action produces a verified PR.
• Rate limiting — @workkit/ratelimit on all API endpoints
• Structured logging — @workkit/logger for observability

Launch (v1.0.0) (#46)

• mainahq.com — Project domain, docs at docs.mainahq.com
• GitHub org — github.com/mainahq
• npm scope — @mainahq/cli, @mainahq/core, @mainahq/mcp, @mainahq/skills
• Org structure — Core and community teams, branch protection, CODEOWNERS
• Show HN, dev.to article — Launch announcement
• GitHub Discussions, issue templates, CONTRIBUTING.md — Community infrastructure
• 1167+ tests across 102 files

Workkit packages powering Maina Cloud

Maina Cloud feature	Workkit packages
Team registry + prompt sync	@workkit/d1, @workkit/kv, @workkit/env
Hosted verification	@workkit/queue, @workkit/r2, @workkit/cache
A/B test coordination	@workkit/do
Auth + SSO	@workkit/auth
API protection	@workkit/ratelimit
Dashboard API	@workkit/api
Observability	@workkit/logger
Testing	@workkit/testing

How Maina fits alongside existing tools

PR opened
  │
  ├── GitHub Copilot ──── code suggestions (write)
  ├── CodeRabbit ──────── AI review comments (review)
  ├── DeepSource ──────── static analysis (lint)
  └── Maina ───────────── verification-first layer (verify)
        │
        ├── spec compliance check
        ├── cross-function consistency (AST)
        ├── slop detection (AI-generated patterns)
        ├── AI review with learned prompts
        ├── security (Semgrep, Trivy, ZAP)
        ├── perf/a11y (Lighthouse)
        └── inline PR comments + commit status

Copilot helps write code. CodeRabbit reviews it. DeepSource lints it. Maina verifies it — checks spec compliance, cross-function consistency, and uses prompts that evolve from your team’s actual merge/reject patterns.

Autonomous Actions architecture

┌─────────────────────────────────────────────────────┐
│  mainahq/workflow-action (v0.6.0)                   │
│                                                     │
│  GitHub Issue created                               │
│    → brainstorm (parse issue into spec)             │
│    → plan (scaffold feature)                        │
│    → design (generate ADR + HLD/LLD)                │
│    → implement (AI writes code, TDD)                │
│    → verify (full pipeline, --json)                 │
│    → review (two-stage)                             │
│    → commit (verified)                              │
│    → PR opened with verification proof              │
│                                                     │
│  Human reviews PR → merge or request changes        │
│  Feedback recorded → feeds self-improve-action      │
└─────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────┐
│  mainahq/self-improve-action (v1.1.0)               │
│                                                     │
│  Scheduled: daily or weekly cron                    │
│    → collect all workflow traces since last run      │
│    → analyze: which prompts led to accepted PRs?    │
│    → propose prompt improvements                    │
│    → A/B test against historical data               │
│    → commit improved prompts if >5% improvement     │
│    → rollback if <-5% regression                    │
│                                                     │
│  The RL loop closes automatically:                  │
│  use → observe → improve → deploy → repeat          │
└─────────────────────────────────────────────────────┘

Round-trip Flywheel (v1.1.0) (#70)

• Codebase Wiki — maina wiki init/compile/query/status/lint/ingest. Compiles ~370 articles from code, plans, specs, ADRs, workflow traces. Context Engine Layer 5 with 12% token budget allocation.
• Universal install script — curl -fsSL https://api.mainahq.com/install | bash. Detects OS, installs maina, finds AI tools, configures MCP automatically.
• maina setup — Guided first-time setup: detects IDE, configures MCP, runs init + doctor
• 12-tool MCP support — Claude Code, Cursor, Windsurf, Cline, Roo Code, Continue.dev, Amazon Q, Zed, Aider, Codex, Gemini CLI, and any MCP-compatible tool
• 10 MCP tools — Added wikiQuery and wikiStatus
• 8 cross-platform skills — Added wiki-workflow, cloud-workflow, onboarding
• Wiki lint — 9 automated checks: stale articles, orphan refs, broken links, spec drift, decision violations, coverage gaps, missing rationale, contradictions
• mainahq/self-improve-action — Autonomous RL loop — Scheduled cron Action (daily/weekly) that collects traces across all recent workflows, analyzes prompt effectiveness, proposes improvements, A/B tests them against historical data, and commits better prompts automatically.

v1.2.0 — Dashboard + Billing (#44)

• Metrics API — Verification pass rate, cache hit rate, tokens saved, prompt evolution
• Dashboard UI — CF Pages frontend at app.mainahq.com
• Billing — Free tier (100 verifications/month), paid tiers via Stripe
• OpenAPI docs — Full API spec at docs.mainahq.com/api via @workkit/api
• SSO — Single sign-on for teams

v1.3.0 — CF Workers Skill + Cross-Dogfooding (#45)

• CF Workers Maina skill — Auto-detects wrangler.toml, loads Workers-specific rules and prompts
• Cross-dogfooding report — Quantitative analysis: bugs found, prompts evolved, patterns learned

v2.0.0 — Enterprise

• Air-gapped deployment — On-premise with audit logging, SOC 2 compliance
• Custom model fine-tuning — From your team’s accepted reviews and feedback
• Chrome extension — Review AI-generated code in GitHub PRs
• transformContext hooks — Programmatic context manipulation
• Self-extending agent — Maina proposes its own extensions based on usage patterns

Contributing

Maina is open source and welcomes contributions.

Getting started

git clone https://github.com/mainahq/maina
cd maina
bun install
bun run build
bun run test

Development commands

bun run dev          # Dev mode with watch
bun run check        # Biome lint + format check
bun run typecheck    # tsc --noEmit
bun run verify       # Full verification: check + typecheck + test

Conventions

• Conventional commits with scopes: cli, core, mcp, skills, docs, ci
• TDD always — write tests first, watch them fail, implement, watch them pass
• Result pattern — Result<T, E> for error handling, never throw
• Bun only — Bun runtime, bun:test, bun:sqlite. Not Node.js, not Jest, not Vitest.

Where to contribute

• New language profiles — Add a LanguageProfile in packages/core/src/language/profile.ts
• New analysis tools — Add a tool adapter in packages/core/src/verify/
• Linter parsers — Add output parsers in packages/core/src/verify/linters/
• Skills — Write new SKILL.md files in packages/skills/
• Documentation — Improve these docs in packages/docs/
• Bug reports and feature requests — Open a GitHub Issue

Dogfooding

Every commit to Maina goes through maina commit. If you contribute, use maina commit for your commits too. If a gate is noisy, fix the gate — do not skip it.