anycrew 0.0.0-stage → 0.1.0

package/lib/cli.mjs

@@ -0,0 +1,184 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import { loadPack, loadPreset, TOOLS, TIERS, modelFor } from './pack.mjs';
+import { generate, scaffoldDocs } from './generate.mjs';
+import { newReport, readIf, exists } from './fsx.mjs';
+
+const CONFIG_REL = path.join('.anycrew', 'config.json');
+
+const HELP = `anycrew — one crew of specialist agents for any coding assistant
+
+Usage:
+  anycrew init   [--preset <id|file>] [--tools a,b|all] [--name <project>] [--purpose "<text>"]
+                 [--dir <path>] [--all-docs] [--force]
+  anycrew sync   [--tools a,b|all] [--dir <path>] [--force]
+  anycrew doctor [--dir <path>]
+  anycrew list   [--dir <path>]
+  anycrew presets
+  anycrew --version | --help
+
+Tools: ${TOOLS.join(', ')}   (default: the assistants detected on this machine or in the repo)
+Presets: see \`anycrew presets\`.
+`;
+
+export async function main(argv) {
+  const { cmd, opts } = parseArgs(argv);
+  if (opts.version) { console.log(loadPack().version); return 0; }
+  if (!cmd || opts.help || cmd === 'help') { console.log(HELP); return 0; }
+  const projectDir = path.resolve(opts.dir ?? process.cwd());
+  switch (cmd) {
+    case 'init': return init(projectDir, opts);
+    case 'sync': return sync(projectDir, opts);
+    case 'doctor': return doctor(projectDir);
+    case 'list': return list(projectDir);
+    case 'presets': return presets();
+    default: console.error(`unknown command "${cmd}"\n${HELP}`); return 2;
+  }
+}
+
+function parseArgs(argv) {
+  const opts = {}; let cmd = null;
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith('--')) {
+      const k = a.slice(2).replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+      const next = argv[i + 1];
+      if (next !== undefined && !next.startsWith('--')) { opts[k] = next; i++; } else opts[k] = true;
+    } else if (!cmd) cmd = a;
+  }
+  return { cmd, opts };
+}
+
+function readConfig(projectDir) {
+  const txt = readIf(path.join(projectDir, CONFIG_REL));
+  if (!txt) return null;
+  return JSON.parse(txt);
+}
+
+function resolveTools(opt, projectDir) {
+  if (opt === 'all') return [...TOOLS];
+  if (typeof opt === 'string') {
+    const list = opt.split(',').map((s) => s.trim()).filter(Boolean);
+    const bad = list.filter((t) => !TOOLS.includes(t));
+    if (bad.length) throw new Error(`unknown tool(s): ${bad.join(', ')} (known: ${TOOLS.join(', ')})`);
+    return list;
+  }
+  const d = detect(projectDir);
+  const found = TOOLS.filter((t) => d[t].cli || d[t].dir);
+  return found.length ? found : ['claude', 'codex', 'antigravity'];
+}
+
+function detect(projectDir) {
+  const has = (bin) => { try { execSync(`command -v ${bin}`, { stdio: 'ignore', shell: '/bin/sh' }); return true; } catch { return false; } };
+  const dir = (p) => exists(path.join(projectDir, p));
+  return {
+    claude: { cli: has('claude'), dir: dir('.claude') || dir('CLAUDE.md'), reads: 'AGENTS.md/CLAUDE.md, .claude/{agents,skills,rules}, .claude/settings.json hooks' },
+    codex: { cli: has('codex'), dir: dir('.codex'), reads: 'AGENTS.md, .agents/skills, .codex/agents/*.toml' },
+    antigravity: { cli: has('agy'), dir: dir('.agents/agents') || dir('.agents/rules'), reads: 'AGENTS.md, .agents/{rules,skills,agents}, .agents/hooks.json' },
+    cursor: { cli: has('cursor') || has('cursor-agent'), dir: dir('.cursor'), reads: 'AGENTS.md, .cursor/{rules,agents}, .agents/skills, .cursor/hooks.json' },
+    opencode: { cli: has('opencode'), dir: dir('.opencode'), reads: 'AGENTS.md, .agents/skills, .opencode/agents' },
+    copilot: { cli: has('copilot'), dir: dir('.github/copilot-instructions.md') || dir('.github/agents'), reads: '.github/copilot-instructions.md, .github/{instructions,agents,hooks}, .agents/skills' },
+  };
+}
+
+async function init(projectDir, opts) {
+  const pack = loadPack();
+  const preset = loadPreset(pack, opts.preset);
+  const existing = readConfig(projectDir);
+  const tools = resolveTools(opts.tools, projectDir);
+  const config = {
+    $schema: 'https://raw.githubusercontent.com/fadlytanjung/anycrew/main/schemas/config.schema.json',
+    version: 1,
+    anycrew: pack.version,
+    project: opts.name ?? existing?.project ?? path.basename(projectDir),
+    purpose: opts.purpose ?? existing?.purpose ?? '',
+    preset: preset.id,
+    tools,
+    commands: existing?.commands ?? { ...preset.commands },
+    models: existing?.models ?? {},
+    agents: existing?.agents ?? { exclude: [] },
+    skills: existing?.skills ?? { exclude: [] },
+    hooks: existing?.hooks ?? { lint_after_edit: preset.hooks?.lint_after_edit !== false },
+  };
+  fs.mkdirSync(path.join(projectDir, '.anycrew'), { recursive: true });
+  fs.writeFileSync(path.join(projectDir, CONFIG_REL), JSON.stringify(config, null, 2) + '\n');
+  const report = newReport();
+  report.written.push(path.join(projectDir, CONFIG_REL));
+  scaffoldDocs({ pack, config, preset, projectDir, report, all: !!opts.allDocs });
+  generate({ pack, config, preset, projectDir, tools, force: !!opts.force, report });
+  print(report, projectDir);
+  console.log(`\nInitialised ${config.project} with preset "${preset.id}" for: ${tools.join(', ')}.`);
+  console.log('Next: open your assistant in this folder and run /crew-status (or /crew-brainstorm for a new idea).');
+  return 0;
+}
+
+async function sync(projectDir, opts) {
+  const pack = loadPack();
+  const config = readConfig(projectDir);
+  if (!config) throw new Error(`no ${CONFIG_REL} here; run \`anycrew init\` first`);
+  const preset = loadPreset(pack, config.preset);
+  const tools = opts.tools ? resolveTools(opts.tools, projectDir) : config.tools;
+  const report = newReport();
+  generate({ pack, config, preset, projectDir, tools, force: !!opts.force, report });
+  print(report, projectDir);
+  return 0;
+}
+
+function print(report, projectDir) {
+  const rel = (p) => path.relative(projectDir, p) || p;
+  if (report.written.length) { console.log(`Written (${report.written.length}):`); for (const p of report.written) console.log(`  + ${rel(p)}`); }
+  if (report.unchanged.length) console.log(`Unchanged: ${report.unchanged.length} file(s)`);
+  if (report.skipped.length) { console.log('Skipped:'); for (const s of report.skipped) console.log(`  ! ${rel(s.path)} — ${s.reason}`); }
+  for (const n of report.notes) console.log(`  · ${n}`);
+}
+
+async function doctor(projectDir) {
+  const pack = loadPack();
+  const config = readConfig(projectDir);
+  const d = detect(projectDir);
+  console.log(`anycrew ${pack.version} · project: ${projectDir}`);
+  console.log(config ? `config: ${CONFIG_REL} (preset ${config.preset}; tools ${config.tools.join(', ')})` : `config: none — run \`anycrew init\``);
+  console.log('\nAssistant      CLI    Files in repo   Reads');
+  for (const t of TOOLS) {
+    console.log(`${t.padEnd(14)} ${(d[t].cli ? 'yes' : 'no').padEnd(6)} ${(d[t].dir ? 'yes' : 'no').padEnd(15)} ${d[t].reads}`);
+  }
+  const checks = [
+    ['AGENTS.md', exists(path.join(projectDir, 'AGENTS.md'))],
+    ['docs/00-constitution.md', exists(path.join(projectDir, 'docs', '00-constitution.md'))],
+    ['docs/20-implementation-status.md', exists(path.join(projectDir, 'docs', '20-implementation-status.md'))],
+    ['.agents/skills', exists(path.join(projectDir, '.agents', 'skills'))],
+    ['.anycrew/hooks/lint-after-edit.sh', exists(path.join(projectDir, '.anycrew', 'hooks', 'lint-after-edit.sh'))],
+  ];
+  console.log('\nProject files');
+  for (const [name, ok] of checks) console.log(`  ${ok ? '✔' : '✘'} ${name}`);
+  if (config?.commands?.check) console.log(`\nCheck command: ${config.commands.check}`);
+  return 0;
+}
+
+async function list(projectDir) {
+  const pack = loadPack();
+  const config = readConfig(projectDir) ?? {};
+  const over = config.models ?? {};
+  const cell = (tool, tier) => {
+    const m = modelFor(pack.models, over, tool, tier);
+    if (m === undefined || m === null || m === '') return 'inherit';
+    if (typeof m === 'object') return [m.model, m.effort ?? m.model_reasoning_effort].filter(Boolean).join('/') || 'inherit';
+    return String(m);
+  };
+  const head = ['agent', 'tier', ...TOOLS];
+  const rows = pack.agents.map((a) => [a.id, a.data.tier, ...TOOLS.map((t) => cell(t, a.data.tier))]);
+  const widths = head.map((h, i) => Math.max(h.length, ...rows.map((r) => String(r[i]).length)));
+  const line = (r) => r.map((c, i) => String(c).padEnd(widths[i])).join('  ');
+  console.log(line(head)); console.log(widths.map((w) => '-'.repeat(w)).join('  '));
+  for (const r of rows) console.log(line(r));
+  console.log(`\nTiers: ${TIERS.map((t) => `${t} = ${pack.models.tiers[t].purpose}`).join('\n       ')}`);
+  console.log(`Skills (${pack.skills.length}): ${pack.skills.map((s) => '/' + s.id).join(' ')}`);
+  return 0;
+}
+
+async function presets() {
+  const pack = loadPack();
+  for (const p of Object.values(pack.presets)) console.log(`${p.id.padEnd(24)} ${p.name}\n${' '.repeat(24)} ${p.description}`);
+  return 0;
+}

package/lib/frontmatter.mjs

@@ -0,0 +1,80 @@
+// Minimal YAML front matter reader/writer. Supports scalars, quoted strings, inline arrays
+// ([a, b]), block lists (- item) and one level of nested maps (key:\n  sub: value). That is all
+// anycrew's own files use; it is not a general YAML parser.
+
+export function parse(text) {
+  const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(text);
+  if (!m) return { data: {}, body: text };
+  const data = {};
+  const lines = m[1].split(/\r?\n/);
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (!line.trim() || line.trim().startsWith('#')) { i++; continue; }
+    const kv = /^([A-Za-z0-9_-]+):\s*(.*)$/.exec(line);
+    if (!kv) { i++; continue; }
+    const key = kv[1];
+    let raw = kv[2].trim();
+    if (raw === '' || raw === '|' || raw === '>-' || raw === '>' || raw === '|-') {
+      // block: nested map, block list, or folded/literal string
+      const block = [];
+      i++;
+      while (i < lines.length && (/^\s+\S/.test(lines[i]) || lines[i].trim() === '')) { block.push(lines[i]); i++; }
+      const nonEmpty = block.filter((l) => l.trim());
+      if (raw === '' && nonEmpty.every((l) => /^\s*-\s/.test(l))) {
+        data[key] = nonEmpty.map((l) => scalar(l.replace(/^\s*-\s*/, '')));
+      } else if (raw === '' && nonEmpty.every((l) => /^\s*[A-Za-z0-9_-]+:\s*/.test(l))) {
+        const obj = {};
+        for (const l of nonEmpty) { const s = /^\s*([A-Za-z0-9_-]+):\s*(.*)$/.exec(l); obj[s[1]] = scalar(s[2]); }
+        data[key] = obj;
+      } else {
+        const joined = nonEmpty.map((l) => l.trim());
+        data[key] = raw.startsWith('|') ? joined.join('\n') : joined.join(' ');
+      }
+      continue;
+    }
+    data[key] = scalar(raw);
+    i++;
+  }
+  return { data, body: m[2] };
+}
+
+function scalar(raw) {
+  raw = raw.trim();
+  if (/^\[.*\]$/.test(raw)) {
+    const inner = raw.slice(1, -1).trim();
+    return inner ? inner.split(',').map((s) => scalar(s)) : [];
+  }
+  if (/^"(.*)"$/.test(raw)) return raw.slice(1, -1).replace(/\\"/g, '"');
+  if (/^'(.*)'$/.test(raw)) return raw.slice(1, -1).replace(/''/g, "'");
+  if (raw === 'true') return true;
+  if (raw === 'false') return false;
+  if (raw === 'null' || raw === '~') return null;
+  return raw;
+}
+
+export function stringify(data, body = '') {
+  const out = ['---'];
+  for (const [k, v] of Object.entries(data)) {
+    if (v === undefined || v === null || v === '') continue;
+    if (Array.isArray(v)) {
+      if (v.length === 0) continue;
+      out.push(`${k}:`);
+      for (const item of v) out.push(`  - ${q(item)}`);
+    } else if (typeof v === 'object') {
+      out.push(`${k}:`);
+      for (const [sk, sv] of Object.entries(v)) out.push(`  ${sk}: ${q(sv)}`);
+    } else {
+      out.push(`${k}: ${q(v)}`);
+    }
+  }
+  out.push('---');
+  return `${out.join('\n')}\n${body.startsWith('\n') ? body.slice(1) : body}`;
+}
+
+function q(v) {
+  if (typeof v === 'boolean' || typeof v === 'number') return String(v);
+  const s = String(v);
+  if (/^[A-Za-z0-9_./*-][^:#"'\n]*$/.test(s) && !/\s{2,}/.test(s) && !/^(true|false|null|~)$/.test(s)) return s;
+  return JSON.stringify(s);
+}

package/lib/fsx.mjs

@@ -0,0 +1,35 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export const MARKER = 'anycrew:generated';
+
+export function readIf(p) { try { return fs.readFileSync(p, 'utf8'); } catch { return null; } }
+export function exists(p) { try { fs.accessSync(p); return true; } catch { return false; } }
+export function mkdirp(p) { fs.mkdirSync(p, { recursive: true }); }
+
+/** Write a generated file. Refuses to overwrite a file that lacks the marker unless force. */
+export function writeGenerated(p, content, report, { force = false } = {}) {
+  const current = readIf(p);
+  if (current !== null && !current.includes(MARKER) && !force) {
+    report.skipped.push({ path: p, reason: 'exists and is not anycrew-generated (use --force)' });
+    return false;
+  }
+  if (current === content) { report.unchanged.push(p); return true; }
+  mkdirp(path.dirname(p));
+  fs.writeFileSync(p, content);
+  report.written.push(p);
+  return true;
+}
+
+/** Write a file only when it does not exist yet (hand-maintained docs). */
+export function writeIfMissing(p, content, report) {
+  if (exists(p)) { report.unchanged.push(p); return false; }
+  mkdirp(path.dirname(p));
+  fs.writeFileSync(p, content);
+  report.written.push(p);
+  return true;
+}
+
+export function newReport() { return { written: [], unchanged: [], skipped: [], notes: [] }; }
+
+export function listDir(p) { try { return fs.readdirSync(p, { withFileTypes: true }); } catch { return []; } }

package/lib/generate.mjs

@@ -0,0 +1,244 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { stringify } from './frontmatter.mjs';
+import { MARKER, writeGenerated, writeIfMissing, readIf, mkdirp, exists } from './fsx.mjs';
+import { modelFor } from './pack.mjs';
+
+const HEAD = (src) => `<!-- ${MARKER} from ${src} — edit the source and run \`npx anycrew sync\` -->\n`;
+const HOOK_REL = '.anycrew/hooks/lint-after-edit.sh';
+
+export function fill(text, vars) {
+  return text.replace(/\{\{([a-z_]+)\}\}/g, (_, k) => (vars[k] ?? `{{${k}}}`));
+}
+
+/** Variables shared by every template, derived from the project config and preset. */
+export function templateVars(config, preset) {
+  const c = { ...preset.commands, ...(config.commands ?? {}) };
+  const l = preset.layout ?? {};
+  const sketch = [
+    `${config.project}/`,
+    '├── AGENTS.md                  agent guide (read first)',
+    '├── docs/                      specs, ADRs, status',
+    l.contracts ? `├── ${l.contracts}/                 machine-readable contracts` : null,
+    l.backend && l.backend !== '.' ? `├── ${l.backend}/` : null,
+    l.frontend ? `├── ${l.frontend}/` : null,
+    '└── .agents/                   rules, skills, agents (anycrew)',
+  ].filter(Boolean).join('\n');
+  const bullets = (arr) => (arr && arr.length ? arr.map((s) => `- ${s}`).join('\n') : '');
+  return {
+    project: config.project,
+    purpose: config.purpose || '',
+    preset: preset.id,
+    setup_cmd: c.setup, dev_cmd: c.dev, check_cmd: c.check, test_cmd: c.test, lint_cmd: c.lint,
+    deploy_cmd: c.deploy ?? 'TODO: deploy command',
+    contracts_dir: l.contracts || 'contracts',
+    prompts_dir: l.backend && l.backend !== '.' ? `${l.backend}/app/prompts/` : 'prompts/',
+    layout_sketch: sketch,
+    backend_conventions: preset.backend_conventions?.length ? `### Backend\n${bullets(preset.backend_conventions)}` : '',
+    frontend_conventions: preset.frontend_conventions?.length ? `### Frontend\n${bullets(preset.frontend_conventions)}` : '',
+    date: new Date().toISOString().slice(0, 10),
+  };
+}
+
+/** The effective rule set: canonical rules plus preset-derived stack rules. */
+export function effectiveRules(pack, preset) {
+  const rules = pack.rules.map((r) => ({ ...r, globs: [] }));
+  const pr = preset.rules ?? {};
+  const llm = rules.find((r) => r.id.startsWith('50-'));
+  if (llm) llm.globs = pr.llm_globs ?? [];
+  const add = (id, title, items, globs) => {
+    if (!items?.length || !globs?.length) return;
+    rules.push({
+      id, globs, data: { trigger: 'glob', globs: globs.join(', '), description: `${title} conventions for ${preset.name}.` },
+      body: `# ${title} conventions\n\n${items.map((s) => `- ${s}`).join('\n')}\n`,
+    });
+  };
+  add('20-backend', 'Backend', preset.backend_conventions, pr.backend_globs);
+  add('30-frontend', 'Frontend', preset.frontend_conventions, pr.frontend_globs);
+  return rules.sort((a, b) => a.id.localeCompare(b.id));
+}
+
+function selected(list, excludes = []) { return list.filter((x) => !excludes.includes(x.id)); }
+
+export function generate({ pack, config, preset, projectDir, tools, force = false, report }) {
+  const vars = templateVars(config, preset);
+  const rules = effectiveRules(pack, preset);
+  const agents = selected(pack.agents, config.agents?.exclude);
+  const skills = selected(pack.skills, config.skills?.exclude);
+  const over = config.models ?? {};
+  const P = (...p) => path.join(projectDir, ...p);
+  const w = (rel, content) => writeGenerated(P(rel), content, report, { force });
+
+  // ---- Universal layer: AGENTS.md, .agents/{rules,skills,agents}, hook script ----
+  const agentsMd = fill(pack.templates.read('AGENTS.md'), vars);
+  if (!exists(P('AGENTS.md'))) writeIfMissing(P('AGENTS.md'), agentsMd, report);
+  else report.notes.push('AGENTS.md exists; left untouched (it is yours to edit).');
+
+  for (const r of rules) {
+    const fm = { trigger: r.data.trigger, description: r.data.description };
+    if (r.data.trigger === 'glob' || (r.globs.length && r.data.trigger === 'model_decision')) {
+      if (r.globs.length) { fm.trigger = 'glob'; fm.globs = r.globs.join(', '); }
+    }
+    w(`.agents/rules/${r.id}.md`, stringify(fm, HEAD('anycrew/rules') + '\n' + r.body));
+  }
+  for (const s of skills) {
+    w(`.agents/skills/${s.id}/SKILL.md`, stringify(s.data, HEAD(`anycrew/skills/${s.id}`) + '\n' + s.body));
+    copyExtras(s.dir, P('.agents', 'skills', s.id), report, force);
+  }
+  if (tools.includes('antigravity')) {
+    for (const a of agents) {
+      const fm = { name: a.data.name, description: a.data.description, model: modelFor(pack.models, over, 'antigravity', a.data.tier) ?? 'inherit' };
+      w(`.agents/agents/${a.id}.md`, stringify(fm, HEAD(`anycrew/agents/${a.id}`) + '\n' + a.body));
+    }
+  }
+  const hookOn = config.hooks?.lint_after_edit !== false;
+  if (hookOn) {
+    const hp = P(HOOK_REL);
+    const [shebang, ...rest] = pack.hookScript.split('\n');
+    const script = `${shebang}\n# ${MARKER}\n${rest.join('\n')}`;
+    if (writeGenerated(hp, script, report, { force: true })) fs.chmodSync(hp, 0o755);
+  }
+
+  // ---- Claude Code ----
+  if (tools.includes('claude')) {
+    w('CLAUDE.md', `${HEAD('anycrew/templates/CLAUDE.md')}@AGENTS.md\n`);
+    for (const a of agents) {
+      const m = modelFor(pack.models, over, 'claude', a.data.tier);
+      const fm = { name: a.data.name, description: a.data.description };
+      if (m && typeof m === 'object') { fm.model = m.model; if (m.effort) fm.effort = m.effort; } else if (m) fm.model = m;
+      if (a.data.tools) fm.tools = a.data.tools;
+      w(`.claude/agents/${a.id}.md`, stringify(fm, HEAD(`anycrew/agents/${a.id}`) + '\n' + a.body));
+    }
+    for (const s of skills) {
+      w(`.claude/skills/${s.id}/SKILL.md`, stringify(s.data, HEAD(`anycrew/skills/${s.id}`) + '\n' + s.body));
+      copyExtras(s.dir, P('.claude', 'skills', s.id), report, force);
+    }
+    for (const r of rules) {
+      const fm = {};
+      if (r.globs.length) fm.paths = r.globs;
+      w(`.claude/rules/${r.id}.md`, (r.globs.length ? stringify(fm, '') : '') + HEAD('anycrew/rules') + '\n' + r.body);
+    }
+    if (hookOn) mergeClaudeSettings(P('.claude', 'settings.json'), report);
+  }
+
+  // ---- Codex ----
+  if (tools.includes('codex')) {
+    for (const a of agents) {
+      const m = modelFor(pack.models, over, 'codex', a.data.tier) ?? {};
+      const lines = [`# ${MARKER} from anycrew/agents/${a.id} — edit the source and run \`npx anycrew sync\``,
+        `name = ${JSON.stringify(a.data.name)}`, `description = ${JSON.stringify(a.data.description)}`];
+      if (m.model) lines.push(`model = ${JSON.stringify(m.model)}`);
+      if (m.model_reasoning_effort) lines.push(`model_reasoning_effort = ${JSON.stringify(m.model_reasoning_effort)}`);
+      lines.push('', `developer_instructions = '''`, a.body.replace(/'''/g, "''\\'"), `'''`, '');
+      w(`.codex/agents/${a.id}.toml`, lines.join('\n'));
+    }
+    report.notes.push('Codex reads AGENTS.md and .agents/skills natively; custom agents are in .codex/agents/*.toml.');
+  }
+
+  // ---- Antigravity hooks ----
+  if (tools.includes('antigravity') && hookOn) {
+    const hooks = { $comment: MARKER, 'anycrew-lint': { PostToolUse: [{ matcher: 'write_to_file|replace_file_content|multi_replace_file_content', hooks: [{ type: 'command', command: `./${HOOK_REL}`, timeout: 60 }] }] } };
+    mergeJsonNamed(P('.agents', 'hooks.json'), 'anycrew-lint', hooks['anycrew-lint'], report);
+  }
+
+  // ---- Cursor ----
+  if (tools.includes('cursor')) {
+    for (const r of rules) {
+      const always = r.data.trigger === 'always_on';
+      const fm = { description: r.data.description };
+      if (r.globs.length) fm.globs = r.globs.join(',');
+      fm.alwaysApply = always;
+      w(`.cursor/rules/${r.id}.mdc`, stringify(fm, HEAD('anycrew/rules') + '\n' + r.body));
+    }
+    for (const a of agents) {
+      const fm = { name: a.data.name, description: a.data.description, model: modelFor(pack.models, over, 'cursor', a.data.tier) ?? 'inherit' };
+      w(`.cursor/agents/${a.id}.md`, stringify(fm, HEAD(`anycrew/agents/${a.id}`) + '\n' + a.body));
+    }
+    if (hookOn) mergeCursorHooks(P('.cursor', 'hooks.json'), report);
+    report.notes.push('Cursor reads .agents/skills natively; no skill copies were made under .cursor/.');
+  }
+
+  // ---- OpenCode ----
+  if (tools.includes('opencode')) {
+    for (const a of agents) {
+      const fm = { description: a.data.description, mode: 'subagent' };
+      const m = modelFor(pack.models, over, 'opencode', a.data.tier);
+      if (m) fm.model = m;
+      w(`.opencode/agents/${a.id}.md`, stringify(fm, HEAD(`anycrew/agents/${a.id}`) + '\n' + a.body));
+    }
+    report.notes.push('OpenCode reads AGENTS.md and .agents/skills natively; agents are in .opencode/agents/.');
+  }
+
+  // ---- GitHub Copilot ----
+  if (tools.includes('copilot')) {
+    const alwaysOn = rules.filter((r) => r.data.trigger === 'always_on').map((r) => r.body).join('\n');
+    w('.github/copilot-instructions.md', fill(pack.templates.read('copilot-instructions.md'), { always_on_rules: alwaysOn }));
+    for (const r of rules.filter((r) => r.globs.length)) {
+      w(`.github/instructions/${r.id}.instructions.md`, stringify({ applyTo: r.globs.join(',') }, HEAD('anycrew/rules') + '\n' + r.body));
+    }
+    for (const a of agents) {
+      const fm = { name: a.data.name, description: a.data.description };
+      const m = modelFor(pack.models, over, 'copilot', a.data.tier);
+      if (m) fm.model = m;
+      w(`.github/agents/${a.id}.agent.md`, stringify(fm, HEAD(`anycrew/agents/${a.id}`) + '\n' + a.body));
+    }
+    if (hookOn) {
+      const hooks = { $comment: MARKER, version: 1, hooks: { postToolUse: [{ type: 'command', bash: `./${HOOK_REL}`, timeoutSec: 60 }] } };
+      w('.github/hooks/anycrew.json', JSON.stringify(hooks, null, 2) + '\n');
+    }
+    report.notes.push('Copilot reads AGENTS.md and .agents/skills natively; agents are in .github/agents/.');
+  }
+  return report;
+}
+
+function copyExtras(srcDir, dstDir, report, force) {
+  for (const d of fs.readdirSync(srcDir, { withFileTypes: true })) {
+    if (d.name === 'SKILL.md') continue;
+    const s = path.join(srcDir, d.name); const t = path.join(dstDir, d.name);
+    if (d.isDirectory()) { mkdirp(t); copyExtras(s, t, report, force); }
+    else writeGenerated(t, fs.readFileSync(s, 'utf8'), report, { force: true });
+  }
+}
+
+function mergeClaudeSettings(file, report) {
+  let json = {};
+  const cur = readIf(file);
+  if (cur) { try { json = JSON.parse(cur); } catch { report.skipped.push({ path: file, reason: 'not valid JSON; add the PostToolUse hook by hand' }); return; } }
+  json.hooks ??= {};
+  json.hooks.PostToolUse ??= [];
+  const entry = { matcher: 'Write|Edit|MultiEdit', hooks: [{ type: 'command', command: `"$CLAUDE_PROJECT_DIR"/${HOOK_REL}`, timeout: 60, statusMessage: 'anycrew: linting edited file…' }] };
+  const idx = json.hooks.PostToolUse.findIndex((e) => JSON.stringify(e).includes(HOOK_REL));
+  if (idx >= 0) json.hooks.PostToolUse[idx] = entry; else json.hooks.PostToolUse.push(entry);
+  const out = JSON.stringify(json, null, 2) + '\n';
+  if (out !== cur) { mkdirp(path.dirname(file)); fs.writeFileSync(file, out); report.written.push(file); } else report.unchanged.push(file);
+}
+
+function mergeJsonNamed(file, key, value, report) {
+  let json = {};
+  const cur = readIf(file);
+  if (cur) { try { json = JSON.parse(cur); } catch { report.skipped.push({ path: file, reason: 'not valid JSON' }); return; } }
+  json[key] = value;
+  const out = JSON.stringify(json, null, 2) + '\n';
+  if (out !== cur) { mkdirp(path.dirname(file)); fs.writeFileSync(file, out); report.written.push(file); } else report.unchanged.push(file);
+}
+
+function mergeCursorHooks(file, report) {
+  let json = { version: 1, hooks: {} };
+  const cur = readIf(file);
+  if (cur) { try { json = JSON.parse(cur); } catch { report.skipped.push({ path: file, reason: 'not valid JSON' }); return; } }
+  json.version ??= 1; json.hooks ??= {}; json.hooks.afterFileEdit ??= [];
+  const entry = { command: `./${HOOK_REL}` };
+  if (!json.hooks.afterFileEdit.some((e) => JSON.stringify(e).includes(HOOK_REL))) json.hooks.afterFileEdit.push(entry);
+  const out = JSON.stringify(json, null, 2) + '\n';
+  if (out !== cur) { mkdirp(path.dirname(file)); fs.writeFileSync(file, out); report.written.push(file); } else report.unchanged.push(file);
+}
+
+/** Create the docs skeleton; never overwrites an existing doc. */
+export function scaffoldDocs({ pack, config, preset, projectDir, report, all = false }) {
+  const vars = templateVars(config, preset);
+  const essential = new Set(['README.md', '00-constitution.md', '20-implementation-status.md', 'glossary.md', path.join('adr', 'README.md'), path.join('adr', 'ADR-template.md'), path.join('specs', 'README.md'), path.join('specs', 'NNN-template', 'spec.md'), path.join('specs', 'NNN-template', 'plan.md'), path.join('specs', 'NNN-template', 'tasks.md')]);
+  for (const t of pack.templates.docs) {
+    if (!all && !essential.has(t.rel)) continue;
+    writeIfMissing(path.join(projectDir, 'docs', t.rel), fill(t.text, vars), report);
+  }
+}

package/lib/pack.mjs

@@ -0,0 +1,75 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parse } from './frontmatter.mjs';
+import { listDir, readIf } from './fsx.mjs';
+
+export const PACK_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+export const TOOLS = ['claude', 'codex', 'antigravity', 'cursor', 'opencode', 'copilot'];
+export const TIERS = ['fast', 'balanced', 'strong'];
+
+export function loadPack() {
+  const pkg = JSON.parse(fs.readFileSync(path.join(PACK_ROOT, 'package.json'), 'utf8'));
+  const models = JSON.parse(fs.readFileSync(path.join(PACK_ROOT, 'models.json'), 'utf8'));
+  const agents = listDir(path.join(PACK_ROOT, 'agents'))
+    .filter((d) => d.isFile() && d.name.endsWith('.md'))
+    .map((d) => {
+      const file = path.join(PACK_ROOT, 'agents', d.name);
+      const { data, body } = parse(fs.readFileSync(file, 'utf8'));
+      return { id: d.name.replace(/\.md$/, ''), file, data, body: body.trim() + '\n' };
+    })
+    .sort((a, b) => a.id.localeCompare(b.id));
+  const skills = listDir(path.join(PACK_ROOT, 'skills'))
+    .filter((d) => d.isDirectory())
+    .map((d) => {
+      const dir = path.join(PACK_ROOT, 'skills', d.name);
+      const text = readIf(path.join(dir, 'SKILL.md')) ?? '';
+      const { data, body } = parse(text);
+      return { id: d.name, dir, data, body: body.trim() + '\n', raw: text };
+    })
+    .sort((a, b) => a.id.localeCompare(b.id));
+  const rules = listDir(path.join(PACK_ROOT, 'rules'))
+    .filter((d) => d.isFile() && d.name.endsWith('.md'))
+    .map((d) => {
+      const file = path.join(PACK_ROOT, 'rules', d.name);
+      const { data, body } = parse(fs.readFileSync(file, 'utf8'));
+      return { id: d.name.replace(/\.md$/, ''), file, data, body: body.trim() + '\n' };
+    })
+    .sort((a, b) => a.id.localeCompare(b.id));
+  const presets = Object.fromEntries(
+    listDir(path.join(PACK_ROOT, 'presets'))
+      .filter((d) => d.isFile() && d.name.endsWith('.json'))
+      .map((d) => { const p = JSON.parse(fs.readFileSync(path.join(PACK_ROOT, 'presets', d.name), 'utf8')); return [p.id, p]; }),
+  );
+  const templates = {
+    read: (rel) => fs.readFileSync(path.join(PACK_ROOT, 'templates', rel), 'utf8'),
+    docs: walk(path.join(PACK_ROOT, 'templates', 'docs')),
+  };
+  const hookScript = fs.readFileSync(path.join(PACK_ROOT, 'hooks', 'scripts', 'lint-after-edit.sh'), 'utf8');
+  return { version: pkg.version, models, agents, skills, rules, presets, templates, hookScript };
+}
+
+function walk(root, rel = '') {
+  const out = [];
+  for (const d of listDir(path.join(root, rel))) {
+    const r = path.join(rel, d.name);
+    if (d.isDirectory()) out.push(...walk(root, r));
+    else out.push({ rel: r, text: fs.readFileSync(path.join(root, r), 'utf8') });
+  }
+  return out;
+}
+
+/** Resolve the model setting for a tool and tier, honouring project overrides. */
+export function modelFor(models, overrides, tool, tier) {
+  const base = models.tools?.[tool]?.[tier];
+  const over = overrides?.[tool]?.[tier];
+  if (over !== undefined) return over;
+  return base;
+}
+
+export function loadPreset(pack, idOrPath) {
+  if (!idOrPath) return pack.presets.generic;
+  if (pack.presets[idOrPath]) return pack.presets[idOrPath];
+  if (fs.existsSync(idOrPath)) return JSON.parse(fs.readFileSync(idOrPath, 'utf8'));
+  throw new Error(`unknown preset "${idOrPath}" (available: ${Object.keys(pack.presets).join(', ')})`);
+}