@aksp/opencrew 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+All notable changes to opencrew are documented here.
+The format is based on [Keep a Changelog](https://keepachangelog.com/).
+
+## [1.0.0] — 2026-08-01
+
+### Added
+- npm-style installer: `npx @aksp/opencrew init` scaffolds a full opencrew workspace.
+- `npx @aksp/opencrew update` refreshes only the framework (`_opencrew/core`, catalog
+  skills, `AGENTS.md`) while preserving `crews/`, `_memory/`, IDE bridges and `.env`.
+- Interactive IDE selection during `init` (or `--ide=`, `--all`, non-interactive fallback).
+- Single source of truth: `AGENTS.md`. Every IDE receives only a thin bridge file that
+  points to it — adding a new IDE is one entry in `src/lib/ides.js`.
+- Version stamping via `_opencrew/.opencrew-version`, read by `update`.
+
+### Notes
+- Reformulation of the OpenSquad framework (originally by Renato Asse) published under
+  the `opencrew` name by [aksp](https://www.npmjs.com/~aksp). MIT licensed.

package/LICENSE

@@ -0,0 +1,24 @@
+MIT License
+
+Copyright (c) 2026 aksp
+
+opencrew framework originally created by Renato Asse (https://github.com/renatoasse/opensquad).
+opencrew is an independent distribution/reformulation released under the same MIT terms.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,118 @@
+# opencrew
+
+**Create AI agent crews that work together — right from your IDE.**
+
+opencrew is a multi-agent orchestration framework. Describe what you need in plain
+language and it assembles a team of specialized agents that run as an automated pipeline
+with human approval checkpoints. It works across Claude Code, Cursor, Codex, Gemini CLI,
+OpenCode, Antigravity and more.
+
+> **This is not an original framework — it's my personal build of OpenSquad.**
+> [OpenSquad](https://github.com/renatoasse/opensquad) was created by
+> [Renato Asse](https://github.com/renatoasse) ([Comunidade Sem Codar](https://semcodar.com.br)).
+> I ([aksp](https://www.npmjs.com/~aksp)) use OpenSquad daily and wanted to improve a few
+> things for my own workflow — so `opencrew` is that reworked version, shared in case it
+> helps others too. All credit for the original idea and framework goes to Renato Asse.
+> See [Origin & credits](#origin--credits) below. MIT licensed, same as the original.
+
+---
+
+## Installation
+
+**Prerequisite:** Node.js 20+
+
+```bash
+npx @aksp/opencrew init
+```
+
+`init` scaffolds the workspace in the current folder and asks which AI IDEs you use, then
+generates the right integration files for each. Then:
+
+1. Open the folder in your AI IDE.
+2. Copy `.env.example` to `.env` and fill in keys for the skills you plan to use.
+3. Type `/opencrew` to start — the first run sets up your company profile.
+
+Preselect IDEs (skip the prompt) or configure all of them:
+
+```bash
+npx @aksp/opencrew init --ide=claude-code,codex
+npx @aksp/opencrew init --all
+```
+
+## Updating
+
+Refresh the framework without losing your work:
+
+```bash
+npx @aksp/opencrew update
+```
+
+`update` refreshes only `_opencrew/core`, the catalog skills and `AGENTS.md`.
+Your `crews/`, memory, IDE bridges and `.env` are left untouched.
+
+## Supported IDEs
+
+| IDE | Bridge file(s) generated |
+|-----|--------------------------|
+| Claude Code | `.claude/skills/opencrew/SKILL.md`, `CLAUDE.md` |
+| Codex (OpenAI) | `AGENTS.md` (native) + `.agents/skills/opencrew/SKILL.md` |
+| Cursor | `.cursor/rules/opencrew.mdc` |
+| VS Code + Copilot | `.github/copilot-instructions.md` |
+| OpenCode | `.opencode/commands/opencrew.md` |
+| Antigravity | `.agent/rules/opencrew.md`, `.agent/workflows/opencrew.md` |
+| Gemini CLI | `GEMINI.md` |
+| Qwen Code | `QWEN.md` |
+| Trae | `.trae/rules/opencrew.md` |
+
+Every bridge is a thin pointer to the single source of truth, **`AGENTS.md`**.
+
+## How it works
+
+- **Architect** designs a crew from your description (agents, pipeline, skills).
+- **Sherlock** (optional) analyzes reference profiles to extract real content patterns.
+- **Pipeline Runner** executes the crew, pausing at checkpoints for your approval.
+- **Skills Engine** loads integrations (scraping, design, publishing, email…) on demand,
+  using a two-tier scheme to keep token usage low.
+
+## Commands (inside your IDE)
+
+| Command | What it does |
+|---------|--------------|
+| `/opencrew` | Open the main menu |
+| `/opencrew create <description>` | Create a new crew |
+| `/opencrew run <name>` | Run a crew |
+| `/opencrew list` | List your crews |
+| `/opencrew edit <name>` | Modify a crew |
+| `/opencrew skills` | Browse / install / remove skills |
+
+## For maintainers
+
+See [CONTRIBUTING.md](CONTRIBUTING.md). The golden rule: `AGENTS.md` is the only place
+system instructions live; per-IDE files are generated from `src/lib/ides.js`.
+
+## Origin & credits
+
+`opencrew` is a **reworked distribution of [OpenSquad](https://github.com/renatoasse/opensquad)**,
+the multi-agent orchestration framework created and maintained by
+**[Renato Asse](https://github.com/renatoasse)**, founder of
+[Comunidade Sem Codar](https://semcodar.com.br). The original project, its concept, agent
+model, pipeline design and skill system are his work — please star and follow the
+[upstream repository](https://github.com/renatoasse/opensquad) and watch the
+[launch video](https://www.youtube.com/watch?v=CL1ppI4qHeU).
+
+I use OpenSquad in my day-to-day and made a few changes that fit how I work, which I believe
+can help other people as well. What this build changes relative to upstream:
+
+- **npm installer under my scope** — `npx @aksp/opencrew init` / `update`, with a
+  non-destructive update path that preserves your crews, memory and `.env`.
+- **Single source of truth for multi-IDE** — one canonical `AGENTS.md`; every IDE gets a
+  thin generated bridge file instead of a hand-maintained document per tool.
+- **Token-economy and skill-invocation improvements** to the framework core.
+
+This is an independent, community fork — it is **not** affiliated with or endorsed by
+Renato Asse or Comunidade Sem Codar. If you want the official project, use
+[`npx opensquad init`](https://github.com/renatoasse/opensquad).
+
+## License
+
+MIT — see [LICENSE](LICENSE). Original OpenSquad framework © Renato Asse, also MIT.

package/bin/opencrew.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+// opencrew — CLI entry point
+import { run } from '../src/cli.js';
+
+run(process.argv.slice(2)).catch((err) => {
+  console.error(err?.stack || String(err));
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@aksp/opencrew",
+  "version": "1.0.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "A reworked build of OpenSquad (by Renato Asse) — create AI agent crews that work together, right from your IDE. Multi-agent orchestration with an npm installer.",
+  "type": "module",
+  "bin": {
+    "opencrew": "bin/opencrew.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "templates/",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "start": "node bin/opencrew.js",
+    "test": "node --test tests/*.test.js",
+    "version": "node -e \"require('fs').writeFileSync('templates/_opencrew/.opencrew-version', require('./package.json').version + '\\n')\""
+  },
+  "keywords": [
+    "ai-agents",
+    "multi-agent",
+    "orchestration",
+    "crews",
+    "claude-code",
+    "cursor",
+    "codex",
+    "gemini",
+    "opencode",
+    "cli"
+  ],
+  "author": {
+    "name": "aksp",
+    "url": "https://www.npmjs.com/~aksp"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alberthpalhares/opencrew.git"
+  },
+  "homepage": "https://github.com/alberthpalhares/opencrew#readme",
+  "bugs": {
+    "url": "https://github.com/alberthpalhares/opencrew/issues"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "@inquirer/checkbox": "^5.1.0",
+    "@inquirer/confirm": "^5.1.0"
+  }
+}

package/src/cli.js

@@ -0,0 +1,70 @@
+import { readJson } from './lib/fsx.js';
+import { packageJsonPath } from './lib/paths.js';
+import { allIdeIds } from './lib/ides.js';
+import { init } from './commands/init.js';
+import { update } from './commands/update.js';
+import { c, log, err } from './lib/ui.js';
+
+function parseArgs(argv) {
+  const opts = { _: [] };
+  for (const a of argv) {
+    if (a.startsWith('--')) {
+      const [k, v] = a.slice(2).split('=');
+      opts[k] = v === undefined ? true : v;
+    } else {
+      opts._.push(a);
+    }
+  }
+  return opts;
+}
+
+function help(version) {
+  log(`
+${c.bold(c.cyan('opencrew'))} ${c.dim('v' + version)} — create AI agent crews that work together
+
+${c.bold('Usage')}
+  npx @aksp/opencrew <command> [options]
+
+${c.bold('Commands')}
+  init            Scaffold an opencrew workspace in the current folder
+  update          Refresh the framework (keeps your crews, memory and .env)
+  help            Show this help
+  version         Print the version
+
+${c.bold('Options for init')}
+  --ide=a,b       Preselect IDEs (skip the prompt). Valid: ${allIdeIds().join(', ')}
+  --all           Configure every supported IDE
+  --yes           Non-interactive; accept defaults
+
+${c.bold('Examples')}
+  npx @aksp/opencrew init
+  npx @aksp/opencrew init --ide=claude-code,codex
+  npx @aksp/opencrew init --all
+  npx @aksp/opencrew update
+`);
+}
+
+export async function run(argv) {
+  const opts = parseArgs(argv);
+  const pkg = await readJson(packageJsonPath);
+  const version = pkg.version;
+  const cmd = opts._[0] || (opts.help ? 'help' : 'init');
+
+  switch (cmd) {
+    case 'init':
+      return init(opts);
+    case 'update':
+    case 'upgrade':
+      return update(opts);
+    case 'version':
+    case '--version':
+      return log(version);
+    case 'help':
+    case '--help':
+      return help(version);
+    default:
+      err(`Unknown command: ${cmd}`);
+      help(version);
+      process.exitCode = 1;
+  }
+}

package/src/commands/init.js

@@ -0,0 +1,97 @@
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { templatesDir, packageJsonPath } from '../lib/paths.js';
+import { copyDir, exists, writeFileSafe, readJson } from '../lib/fsx.js';
+import { IDES, ideById, allIdeIds } from '../lib/ides.js';
+import { pickIdes } from '../lib/prompts.js';
+import { c, log, info, ok, warn, step } from '../lib/ui.js';
+
+export async function init(opts = {}) {
+  const target = process.cwd();
+  const pkg = await readJson(packageJsonPath);
+  const version = pkg.version;
+
+  log(`\n${c.bold(c.cyan('opencrew'))} ${c.dim('v' + version)} — scaffolding a crew workspace`);
+  log(c.dim(`Target: ${target}\n`));
+
+  const alreadyInstalled = await exists(path.join(target, '_opencrew', 'core'));
+  if (alreadyInstalled) {
+    warn('An opencrew workspace already exists here.');
+    warn(`Framework files are refreshed but your crews, memory and .env are kept intact.`);
+    warn(`To update only the framework, use: ${c.cyan('npx @aksp/opencrew update')}\n`);
+  }
+
+  // 1. Copy the framework payload (never clobber user work).
+  step('Installing framework files');
+  const copied = { count: 0 };
+  await copyDir(path.join(templatesDir, '_opencrew'), path.join(target, '_opencrew'), {
+    overwrite: false,
+    // Never ship stray logs or browser sessions; keep the empty dir via .gitkeep only.
+    skip: (rel) =>
+      (rel.startsWith('logs/') && rel !== 'logs/.gitkeep') ||
+      rel.startsWith('_browser_profile/'),
+    onCopy: () => (copied.count += 1),
+  });
+  await copyDir(path.join(templatesDir, 'skills'), path.join(target, 'skills'), {
+    overwrite: false,
+    onCopy: () => (copied.count += 1),
+  });
+  await copyDir(path.join(templatesDir, 'crews'), path.join(target, 'crews'), {
+    overwrite: false,
+  });
+  ok(`Framework files ready (${copied.count} written, existing files preserved)`);
+
+  // 2. Canonical system doc + root configs.
+  step('Writing configuration');
+  await writeFileSafe(path.join(target, 'AGENTS.md'), await tpl('AGENTS.md'));
+  ok('AGENTS.md (single source of truth)');
+
+  const mcpWritten = await writeFileSafe(path.join(target, '.mcp.json'), await tpl('.mcp.json'), {
+    overwrite: false,
+  });
+  info(mcpWritten ? '.mcp.json' : '.mcp.json (kept existing)');
+
+  await writeFileSafe(path.join(target, '.env.example'), await tpl('.env.example'));
+  const giWritten = await writeFileSafe(path.join(target, '.gitignore'), await tpl('gitignore'), {
+    overwrite: false,
+  });
+  info(giWritten ? '.gitignore' : '.gitignore (kept existing)');
+
+  // 3. IDE bridge files.
+  step('Configuring AI IDEs');
+  let ids = normalizeIdes(opts.ide);
+  if (opts.all) ids = allIdeIds();
+  if (!ids) ids = await pickIdes();
+
+  for (const id of ids) {
+    const ide = ideById(id);
+    if (!ide) {
+      warn(`Unknown IDE "${id}" — skipped. Valid: ${allIdeIds().join(', ')}`);
+      continue;
+    }
+    for (const f of ide.files) {
+      await writeFileSafe(path.join(target, f.path), f.content);
+    }
+    ok(`${ide.label} → ${ide.files.map((f) => f.path).join(', ')}`);
+  }
+
+  // 4. Version stamp.
+  await fs.writeFile(path.join(target, '_opencrew', '.opencrew-version'), version + '\n');
+
+  // 5. Done.
+  log(`\n${c.green(c.bold('Done!'))} opencrew is installed.\n`);
+  log(`${c.bold('Next steps:')}`);
+  log(`  1. Open this folder in your AI IDE.`);
+  log(`  2. Copy ${c.cyan('.env.example')} to ${c.cyan('.env')} and fill in keys for the skills you use.`);
+  log(`  3. Type ${c.cyan('/opencrew')} to start (first run sets up your company profile).\n`);
+}
+
+async function tpl(name) {
+  return fs.readFile(path.join(templatesDir, name), 'utf8');
+}
+
+function normalizeIdes(val) {
+  if (!val) return null;
+  const list = Array.isArray(val) ? val : String(val).split(',');
+  return list.map((s) => s.trim()).filter(Boolean);
+}

package/src/commands/update.js

@@ -0,0 +1,58 @@
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { templatesDir, packageJsonPath } from '../lib/paths.js';
+import { copyDir, exists, writeFileSafe, readJson } from '../lib/fsx.js';
+import { c, log, info, ok, warn, step } from '../lib/ui.js';
+
+// Update refreshes ONLY the framework. It never touches:
+//   crews/, _opencrew/_memory/, _opencrew/_browser_profile/, .env, IDE bridges.
+export async function update() {
+  const target = process.cwd();
+  const pkg = await readJson(packageJsonPath);
+  const version = pkg.version;
+
+  if (!(await exists(path.join(target, '_opencrew', 'core')))) {
+    warn('No opencrew workspace found here.');
+    info(`Run ${c.cyan('npx @aksp/opencrew init')} first.`);
+    return;
+  }
+
+  const versionFile = path.join(target, '_opencrew', '.opencrew-version');
+  const current = (await exists(versionFile))
+    ? (await fs.readFile(versionFile, 'utf8')).trim()
+    : 'unknown';
+
+  log(`\n${c.bold(c.cyan('opencrew update'))}`);
+  log(c.dim(`Installed: ${current}  →  Package: ${version}\n`));
+
+  if (current === version) {
+    ok('Already up to date. Refreshing framework files anyway.');
+  }
+
+  // Refresh core framework: _opencrew/core is fully overwritten (it is not user data).
+  step('Refreshing framework');
+  let n = 0;
+  await copyDir(path.join(templatesDir, '_opencrew', 'core'), path.join(target, '_opencrew', 'core'), {
+    overwrite: true,
+    onCopy: () => (n += 1),
+  });
+  ok(`_opencrew/core refreshed (${n} files)`);
+
+  // Refresh catalog skills but preserve any user-modified/added ones:
+  // only overwrite skills that ship with the package; leave others untouched.
+  step('Refreshing catalog skills');
+  let s = 0;
+  await copyDir(path.join(templatesDir, 'skills'), path.join(target, 'skills'), {
+    overwrite: true,
+    onCopy: () => (s += 1),
+  });
+  ok(`Catalog skills refreshed (${s} files)`);
+
+  // Canonical system doc.
+  await writeFileSafe(path.join(target, 'AGENTS.md'), await fs.readFile(path.join(templatesDir, 'AGENTS.md'), 'utf8'));
+  ok('AGENTS.md refreshed');
+
+  await fs.writeFile(versionFile, version + '\n');
+  log(`\n${c.green(c.bold('Updated to v' + version))}.`);
+  log(c.dim('Your crews, memory, IDE bridges and .env were left untouched.\n'));
+}

package/src/lib/fsx.js

@@ -0,0 +1,55 @@
+// Filesystem helpers (no external deps).
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+
+export async function exists(p) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function ensureDir(p) {
+  await fs.mkdir(p, { recursive: true });
+}
+
+/**
+ * Recursively copy `src` into `dest`.
+ * @param {object} opts
+ * @param {boolean} opts.overwrite  Overwrite existing files (default false).
+ * @param {(rel:string)=>boolean} opts.skip  Return true to skip a relative path.
+ * @param {(rel:string)=>void} opts.onCopy  Called for each file copied.
+ */
+export async function copyDir(src, dest, opts = {}) {
+  const { overwrite = false, skip = () => false, onCopy, _root = src } = opts;
+  await ensureDir(dest);
+  const entries = await fs.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const from = path.join(src, entry.name);
+    const to = path.join(dest, entry.name);
+    const rel = path.relative(_root, from).split(path.sep).join('/');
+    if (skip(rel)) continue;
+    if (entry.isDirectory()) {
+      await copyDir(from, to, { ...opts, _root });
+    } else {
+      const present = await exists(to);
+      if (present && !overwrite) continue;
+      await ensureDir(path.dirname(to));
+      await fs.copyFile(from, to);
+      if (onCopy) onCopy(rel);
+    }
+  }
+}
+
+export async function writeFileSafe(p, content, { overwrite = true } = {}) {
+  if (!overwrite && (await exists(p))) return false;
+  await ensureDir(path.dirname(p));
+  await fs.writeFile(p, content);
+  return true;
+}
+
+export async function readJson(p) {
+  return JSON.parse(await fs.readFile(p, 'utf8'));
+}

package/src/lib/ides.js

@@ -0,0 +1,120 @@
+// Single source of truth = AGENTS.md (shipped at project root).
+// Every IDE gets only a THIN bridge file that points at AGENTS.md.
+// Adding support for a new IDE = one more entry in this list.
+
+const BRIDGE = `Read \`AGENTS.md\` at the project root and adopt the opencrew system role.
+Follow all initialization, command routing, and workflow instructions defined there.
+
+If invoked with arguments (e.g. \`/opencrew create ...\`, \`/opencrew run ...\`),
+route to the matching action from the Command Routing table in AGENTS.md.
+If invoked without arguments, show the Main Menu.`;
+
+// Claude Code needs one extra rule (checkpoints must use AskUserQuestion) and a
+// note that its own Playwright plugin must be off (opencrew ships its own via .mcp.json).
+const CLAUDE_SKILL = `---
+name: opencrew
+description: "opencrew — multi-agent orchestration. Use when the user types /opencrew or asks to create, run, or manage AI agent crews."
+---
+
+# opencrew (Claude Code entry point)
+
+${BRIDGE}
+
+## Claude Code specifics (override AGENTS.md where they conflict)
+
+- **Checkpoints MUST use \`AskUserQuestion\`** — never output a checkpoint question as plain text.
+  Combine multiple questions into a single call (max 4 slots, each with 2–4 options).
+- Checkpoint steps always run inline (never dispatched as subagents).
+- opencrew uses its own \`@playwright/mcp\` server (see \`.mcp.json\`). The native Claude Code
+  Playwright plugin must be disabled to avoid conflicts.
+`;
+
+const CLAUDE_MD = `# opencrew — Project Instructions
+
+This project uses **opencrew**, a multi-agent orchestration framework.
+The full system definition lives in \`AGENTS.md\` — read it and adopt that role.
+
+Type \`/opencrew\` to open the main menu.
+
+## Notes for Claude Code
+
+- All checkpoint questions use \`AskUserQuestion\`.
+- opencrew ships its own Playwright MCP (\`.mcp.json\`); disable the native Playwright plugin.
+- Do not manually edit files under \`_opencrew/core/\` unless you know what you're doing.
+`;
+
+const render = (title, extra = '') =>
+  `# ${title}\n\n${BRIDGE}${extra ? `\n\n${extra}` : ''}\n`;
+
+/**
+ * Each IDE lists the files its bridge writes. `content` is plain text.
+ * `mdc` files (Cursor) get a small frontmatter so the rule always applies.
+ */
+export const IDES = [
+  {
+    id: 'claude-code',
+    label: 'Claude Code',
+    files: [
+      { path: '.claude/skills/opencrew/SKILL.md', content: CLAUDE_SKILL },
+      { path: 'CLAUDE.md', content: CLAUDE_MD },
+    ],
+  },
+  {
+    id: 'codex',
+    label: 'Codex (OpenAI)',
+    // Codex reads AGENTS.md natively — always shipped. Add a slash-style helper too.
+    files: [
+      { path: '.agents/skills/opencrew/SKILL.md', content: `---\nname: opencrew\ndescription: Run opencrew — multi-agent orchestration. Use when the user types /opencrew or asks to create, run, or manage crews.\n---\n\n${BRIDGE}\n` },
+    ],
+  },
+  {
+    id: 'cursor',
+    label: 'Cursor',
+    files: [
+      { path: '.cursor/rules/opencrew.mdc', content: `---\ndescription: opencrew — multi-agent orchestration framework.\nalwaysApply: true\n---\n\n${BRIDGE}\n` },
+    ],
+  },
+  {
+    id: 'copilot',
+    label: 'VS Code + Copilot',
+    files: [
+      { path: '.github/copilot-instructions.md', content: render('opencrew — Copilot Instructions') },
+    ],
+  },
+  {
+    id: 'opencode',
+    label: 'OpenCode',
+    files: [
+      { path: '.opencode/commands/opencrew.md', content: `---\ndescription: opencrew — Multi-agent orchestration framework. Create and run AI crews.\n---\n\n${BRIDGE}\n` },
+    ],
+  },
+  {
+    id: 'antigravity',
+    label: 'Antigravity (Gemini)',
+    files: [
+      {
+        path: '.agent/rules/opencrew.md',
+        content: `---\nname: opencrew\n---\n\n${BRIDGE}\n\n## Antigravity specifics\n\n- This environment does not support background/parallel subagents. Run all tasks inline and\n  sequentially — never announce parallel work and then skip it.\n- Ask only one question per message; present options as a numbered list.\n`,
+      },
+      { path: '.agent/workflows/opencrew.md', content: render('opencrew Workflow (Antigravity)') },
+    ],
+  },
+  {
+    id: 'gemini',
+    label: 'Gemini CLI',
+    files: [{ path: 'GEMINI.md', content: render('opencrew — Gemini CLI') }],
+  },
+  {
+    id: 'qwen',
+    label: 'Qwen Code',
+    files: [{ path: 'QWEN.md', content: render('opencrew — Qwen Code') }],
+  },
+  {
+    id: 'trae',
+    label: 'Trae',
+    files: [{ path: '.trae/rules/opencrew.md', content: render('opencrew — Trae') }],
+  },
+];
+
+export const ideById = (id) => IDES.find((i) => i.id === id);
+export const allIdeIds = () => IDES.map((i) => i.id);

package/src/lib/paths.js

@@ -0,0 +1,8 @@
+// Resolve locations relative to the installed package.
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = path.dirname(fileURLToPath(import.meta.url)); // src/lib
+export const packageRoot = path.resolve(here, '..', '..');
+export const templatesDir = path.join(packageRoot, 'templates');
+export const packageJsonPath = path.join(packageRoot, 'package.json');

package/src/lib/prompts.js

@@ -0,0 +1,35 @@
+// Interactive prompts with a non-interactive fallback.
+// Uses @inquirer/checkbox when a TTY is available; otherwise returns defaults.
+import { IDES, allIdeIds } from './ides.js';
+import { warn } from './ui.js';
+
+export async function pickIdes({ preselected } = {}) {
+  const isTTY = process.stdin.isTTY && process.stdout.isTTY;
+  if (!isTTY) {
+    const chosen = preselected?.length ? preselected : allIdeIds();
+    warn(`Non-interactive terminal — configuring IDEs: ${chosen.join(', ')}`);
+    return chosen;
+  }
+  const { default: checkbox, Separator } = await import('@inquirer/checkbox');
+  const answer = await checkbox({
+    message: 'Which AI IDEs do you use? (space to toggle, enter to confirm)',
+    instructions: false,
+    choices: [
+      ...IDES.map((i) => ({
+        name: i.label,
+        value: i.id,
+        checked: preselected ? preselected.includes(i.id) : i.id === 'claude-code',
+      })),
+      new Separator(),
+    ],
+    validate: (a) => (a.length ? true : 'Select at least one IDE.'),
+  });
+  return answer;
+}
+
+export async function confirm(message, def = true) {
+  const isTTY = process.stdin.isTTY && process.stdout.isTTY;
+  if (!isTTY) return def;
+  const { default: confirmPrompt } = await import('@inquirer/confirm');
+  return confirmPrompt({ message, default: def });
+}