Orkestra AI

Languages: English · Português (BR) · Español

From ticket to merge without living in six tabs.

A VS Code and Cursor extension that connects Jira, GitHub Issues, Azure DevOps, and ClickUp to your GitHub, Bitbucket Cloud, or GitLab repo, and runs a delivery pipeline with clear steps—refine, assisted implementation, PR, AI review, and fixes—all from the editor.

Website: orkestraai.com.br · Marketplace: Install · Source: github.com/djalexdee/orkestra-ai

What it is (one line)

Orkestra is not “another autocomplete.” It orchestrates the flow between task card, code, and PR—so you stop copying context between Jira, the IDE, and GitHub all day.

• Sidebar board: Kanban for tasks from the active provider.
• Numbered workflow: Refine → Start → Implement → PR → Review → Fix → Finish (with shortcuts).
• Remote PRs: comments, AI analysis, auto-fix with a configurable threshold (GitHub / Bitbucket / GitLab merge requests).

The “aha” moment (real flow)

Picture a vague Jira ticket (“improve checkout performance”).

┌─────────────────────────────────────────────────────────────────┐
│  [Orkestra AI]  Board                    ORK-184  ▼  In Progress │
├─────────────────────────────────────────────────────────────────┤
│  You pick the task on the board                                   │
│       ↓                                                           │
│  ① Refine Task  →  AI + repo scanner  →  criteria + risks         │
│       ↓                                                           │
│  ② Start Task   →  “In Progress” + repo snapshot                  │
│       ↓                                                           │
│  ③ Implement    →  task-grounded prompt in the editor             │
│       ↓                                                           │
│  ④ Create PR    →  open/draft PR on GitHub, Bitbucket, or GitLab  │
│       ↓                                                           │
│  ⑤ Review       →  sync comment thread + AI analysis on the PR    │
│       ↓                                                           │
│  ⑥ Auto Fix     →  mechanical fixes + batch commit (optional)     │
│       ↓                                                           │
│  ⑦ Finish       →  close the loop on the provider                 │
└─────────────────────────────────────────────────────────────────┘

You don’t replace human code review on large changes—but you cut friction between bad tickets, branches, PRs, and repetitive PR comments.

The problem (no fluff)

Orkestra tackles this where you already work: the editor.

The solution

Full workflow (the pipeline)

Real order in code—practical steps:

Default shortcuts (when the editor has focus — when: editorTextFocus). Command IDs are the orkestra.* ones registered in package.json (legacy devTask.* aliases still resolve to the same handlers):

Start task only (board + branch, no implement step) is orkestra.startTask—there is no default keybinding; use the Command Palette.

Command Palette (Ctrl+Shift+P): Orkestra AI category—including orkestra.reviewAdvanced, orkestra.refreshBoard, orkestra.syncRepoWithBoard, orkestra.implementationContinue, orkestra.quickStart, orkestra.linkWorkspace, orkestra.cloudSignIn, orkestra.openBillingUpgrade, etc.

Main features

AI workflow

• Quickstart pipeline (refine + start + implement) and Full / Full with checkpoints (UI confirmations).
• AI orchestrator with intents (refine_task, implement_task, analyze_pr, fix_pr_comment, …) and a provider chain (LM API, chat, fallback).
• Usage gate: plan + quotas before calling a model (see Billing).

PR automation

• Open-PR detection on the branch; full analysis (POST /api/pr/:id/analyze) and zero-friction flow (threshold, batch commit, markdown summary on the PR).
• Resolve comment; PR activity in the repo.

Context & memory

• Project memory (local file + search / reindex); injection into refine, implement, and fixes.
• Per-task timeline and AI summary (where enabled).
• Insights (/api/insights/overview, project, Git).

Integrations

• Tasks: Jira (basic + OAuth), GitHub Issues, Azure DevOps, ClickUp (personal API token or OAuth; OAuth redirect http://localhost:4567/callback).
• Git / PR: GitHub, Bitbucket Cloud, and GitLab merge requests (orkestra.github.*, orkestra.bitbucket.*, orkestra.gitlab.token, optional orkestra.gitlab.instanceHost for self-managed).

Developer experience

• Board webview in the Activity Bar (devTaskSidebar).
• Link / Change / Unlink Workspace for a consistent profile.
• UI language for extension + board webview: orkestra.uiLanguage — auto (follow VS Code locale), pt-br, or en.
• Optional PR → board sync: when orkestra.sync.enable is true, the extension polls the SCM for recently merged PRs and can move linked tasks toward Done (uses persisted PR↔task links from Create PR when available).
• Embedded HTTP API (default port 19850) for automation.
• Output channels for debugging (Workflow, Review, Memory, …).

Straight comparison

Copilot and Cursor shine where you type code. Orkestra helps where work is a full delivery with task + branch + PR.

Plans (from code catalog)

Reference pricing (PLAN_CATALOG—may change at publish time):

Upgrade: Orkestra AI: Upgrade plan / billing or Asaas / cloud flow per your setup.

Installation

VS Code or Cursor

1. Ctrl+Shift+X (or Cmd+Shift+X on Mac) → search Orkestra AI.
2. Marketplace ID: DjAlexDee.orkestra-ai
3. Install and reload the window if prompted.

Or: Extensions → … → Install from VSIX… if you have a .vsix.

Requirements: VS Code ≥ 1.80.0 (or a compatible Cursor build), folder workspace with Git (origin on github.com, bitbucket.org, or GitLab—gitlab.com by default, or a self-managed host matching orkestra.gitlab.instanceHost).

Supported platforms

PR automation supports origin on GitHub, Bitbucket, or GitLab. On GitLab.com (or *.gitlab.com remotes), set orkestra.gitlab.token (PAT with api scope), or GITLAB_TOKEN, or store a token on the board profile when linking the repo. For self-managed GitLab, set orkestra.gitlab.instanceHost to the same hostname as in git remote (e.g. gitlab.acme.com). Task providers (Jira, Azure DevOps, ClickUp, GitHub Issues) work independently of the Git host.

Quick start

1. Install from the Marketplace.
2. Open a folder with your Git clone.
3. Click Orkestra AI in the activity bar → Board opens.
4. In Settings (orkestra), configure at least one provider:
   • orkestra.provider: jira | github | azure | clickup
   • Tokens / domain / list per provider docs.
5. Set GitHub, Bitbucket, and/or GitLab for PRs (orkestra.github.*, orkestra.bitbucket.*, orkestra.gitlab.token [+ orkestra.gitlab.instanceHost if not gitlab.com]).
6. Run Orkestra AI: Link Workspace if prompted to bind folder ↔ profile.
7. Pick a task on the board → Orkestra AI: Refine task, then Orkestra AI: Start and implement (AI) / Orkestra AI: Implement with AI, or Orkestra AI: Run full workflow (Ctrl+Shift+6).

Settings namespace (orkestra.*)

All contributed settings use the orkestra prefix (for example orkestra.provider, orkestra.jira.domain, orkestra.workflow.autoCommitBeforeCreatePr). If you upgraded from a release that used devTaskAssistant.*, the extension copies your saved overrides into orkestra.* on first activation when the new key does not already have a value, so existing installs keep working.

Concept: AI orchestration

“Orchestration” here is literal: a state machine + prompts + integrations, not one giant prompt.

• Workflow events feed memory extraction and timeline.
• Pipelines (refine, review, auto-fix) in stages: gather → build prompt → call model → apply safe output.
• Billing and quotas tied to steps and intents so you don’t blow the plan blindly.

Mental model: task-side CI/CD—inside the IDE.

Architecture (lightweight)

┌──────────────────┐     ┌─────────────────┐     ┌──────────────────┐
│  VS Code /       │     │  Embedded API   │     │  Task providers  │
│  Cursor Host     │────▶│  localhost:19850     │  Jira / GH / ADO  │
│  (extension.js)  │     │  + WebSocket    │     │  / ClickUp       │
└────────┬─────────┘     └────────┬────────┘     └──────────────────┘
         │                        │
         ▼                        ▼
┌──────────────────┐     ┌─────────────────┐
│  AI Orchestrator │     │  Billing        │
│  + gates / usage │     │  Asaas / cloud  │
└────────┬─────────┘     └─────────────────┘
         ▼
┌──────────────────┐
│  SCM: GitHub /   │
│  Bitbucket /     │
│  GitLab MR       │
└──────────────────┘

Security & billing (honest summary)

• Plans and quotas on the host: Free vs Pro changes flags (automation, auto-fix, memory, API) and numeric limits.
• Local API: JWT / API key in production; Asaas webhook requires a token when enabled; WebSocket requires credentials.
• Cloud: orkestra.cloudBillingBaseUrl / ORKESTRA_CLOUD_BILLING_URL + JWT via Orkestra AI: Sign in (cloud billing) (orkestra.cloudSignIn); optional orkestra.cloudAuthBrowserFlow for browser OAuth when the backend supports it; optional analytics events. Orkestra AI: Configure CPF/CNPJ (checkout) (orkestra.configureBillingCpf) when your billing flow requires it.

Details can change by release—see src/saas/ and src/api/.

Roadmap

• GitLab merge requests (GitLab.com + self-managed): shipped (orkestra.gitlab.*). Deeper extras (labels, approvals, …) as the API surface grows.
• Other SCM (e.g. Azure Repos) for the same PR flow where feasible—track issues for status.
• Multi-device sync of core state via backend (less local JSON reliance).
• Richer analytics + offline queues.
• Enterprise: seats, SSO, policies—sales conversation.

Small, focused PRs (one integration or one workflow step) are easier to merge than huge diffs.

Development (from source)

git clone https://github.com/djalexdee/orkestra-ai.git
cd orkestra-ai
npm install
npm run compile

In VS Code: F5 → Extension Development Host.

The Nest cloud billing API is built and deployed from a separate repository (not this extension tree). Set orkestra.cloudBillingBaseUrl (or ORKESTRA_CLOUD_BILLING_URL) and use Orkestra AI: Sign in (cloud billing) for the JWT. HTTP contract, Asaas webhooks, and ops: docs/SAAS_BILLING_ARCHITECTURE.md.

Contributing

1. Open an Issue with the problem or idea (or comment on an existing one).
2. Fork → short-lived branch → PR describing changes and how to test.
3. Prefer small PRs (one theme: bugfix, one provider, one workflow step).

License

MIT — see LICENSE.md.

Links

Note on the marketing site

The site summarizes the product for visitors; this repo is the source of truth. If something diverges (e.g. roadmap integrations), the repository wins. Website copy suggestions are welcome via issues.