@spec-wave/cli 0.5.5 → 0.5.8

package/src/commands/install-skill.mjs

@@ -0,0 +1,292 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import yaml from 'js-yaml';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { homedir } from 'node:os';
+import path from 'node:path';
+
+const __dir = path.dirname(fileURLToPath(import.meta.url));
+// Fonte única da skill, publicada via "files": ["src"] no package.json.
+const SKILL_SOURCE = path.join(__dir, '..', 'templates', 'skill', 'SKILL.md');
+
+// Marcadores usados para gravar/atualizar a skill de forma idempotente em
+// arquivos compartilhados (AGENTS.md) — permite reinstalar sem duplicar.
+const BLOCK_START = '<!-- spec-wave:start -->';
+const BLOCK_END = '<!-- spec-wave:end -->';
+
+// Registro de agentes suportados. Cada alvo descreve como detectá-lo no
+// diretório-base, onde gravar (projeto vs. global) e em que formato converter
+// o SKILL.md. Caminhos conferidos na doc oficial de cada ferramenta.
+const TARGETS = [
+  {
+    key: 'claude',
+    name: 'Claude Code',
+    format: 'skill',
+    detect: ['.claude'],
+    project: '.claude/skills/spec-wave/SKILL.md',
+    global: '.claude/skills/spec-wave/SKILL.md',
+  },
+  {
+    key: 'opencode',
+    name: 'opencode',
+    format: 'skill',
+    detect: ['.opencode'],
+    project: '.opencode/skills/spec-wave/SKILL.md',
+    global: '.config/opencode/skills/spec-wave/SKILL.md',
+  },
+  {
+    key: 'cursor',
+    name: 'Cursor',
+    format: 'mdc',
+    detect: ['.cursor'],
+    project: '.cursor/rules/spec-wave.mdc',
+    global: null, // Cursor user rules não são baseadas em arquivo.
+  },
+  {
+    key: 'cline',
+    name: 'Cline',
+    format: 'rules',
+    detect: ['.clinerules'],
+    project: '.clinerules/spec-wave.md',
+    global: null,
+  },
+  {
+    key: 'kilo',
+    name: 'Kilo Code',
+    format: 'rules',
+    detect: ['.kilocode'],
+    project: '.kilocode/rules/spec-wave.md',
+    global: '.kilocode/rules/spec-wave.md',
+  },
+  {
+    key: 'antigravity',
+    name: 'Antigravity',
+    format: 'rules',
+    detect: ['.agent', 'GEMINI.md'],
+    project: '.agent/rules/spec-wave.md',
+    global: '.gemini/AGENTS.md',
+    globalFormat: 'agents', // ~/.gemini/AGENTS.md é compartilhado → append.
+  },
+  {
+    key: 'agents',
+    name: 'AGENTS.md (genérico)',
+    format: 'agents',
+    detect: ['AGENTS.md'],
+    project: 'AGENTS.md',
+    global: '.config/opencode/AGENTS.md',
+  },
+];
+
+const TARGET_BY_KEY = new Map(TARGETS.map((t) => [t.key, t]));
+
+// Separa o frontmatter YAML do corpo do SKILL.md. Retorna { meta, body }.
+function parseSkill(raw) {
+  const match = raw.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!match) return { meta: {}, body: raw.trim() };
+  let meta = {};
+  try {
+    meta = yaml.load(match[1]) || {};
+  } catch {
+    meta = {};
+  }
+  return { meta, body: match[2].trim() };
+}
+
+// Converte o SKILL.md para o formato exigido por cada agente.
+function renderContent(format, raw, parsed) {
+  const { meta, body } = parsed;
+  const description = meta.description ?? 'Skill spec-wave.';
+  switch (format) {
+    case 'skill':
+      // Claude Code / opencode consomem o SKILL.md nativo. Campos extras do
+      // frontmatter são ignorados pelo opencode — sem problema.
+      return raw.trimEnd() + '\n';
+    case 'mdc':
+      return (
+        `---\n` +
+        `description: ${JSON.stringify(description)}\n` +
+        `alwaysApply: false\n` +
+        `---\n\n` +
+        `${body}\n`
+      );
+    case 'rules':
+      return `# spec-wave\n\n${description}\n\n${body}\n`;
+    case 'agents':
+      return `${BLOCK_START}\n\n# spec-wave\n\n${description}\n\n${body}\n\n${BLOCK_END}\n`;
+    default:
+      return raw;
+  }
+}
+
+// Insere/atualiza o bloco spec-wave num arquivo compartilhado (AGENTS.md),
+// preservando o restante do conteúdo. Idempotente via marcadores.
+function mergeAgentsFile(destPath, block) {
+  const existing = existsSync(destPath) ? readFileSync(destPath, 'utf-8') : '';
+  const blockRe = new RegExp(
+    `${escapeRe(BLOCK_START)}[\\s\\S]*?${escapeRe(BLOCK_END)}\\n?`,
+  );
+  if (blockRe.test(existing)) {
+    return existing.replace(blockRe, block);
+  }
+  if (existing.trim() === '') return block;
+  return `${existing.trimEnd()}\n\n${block}`;
+}
+
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+// Resolve o alvo do agente para um destino concreto no escopo escolhido.
+// Retorna null quando o agente não suporta o escopo global.
+function resolveDest(target, baseDir, isGlobal) {
+  const rel = isGlobal ? target.global : target.project;
+  if (!rel) return null;
+  const format = isGlobal && target.globalFormat ? target.globalFormat : target.format;
+  return { path: path.join(baseDir, rel), format };
+}
+
+// Retorna true se algum dos sinais de detecção existir em baseDir.
+function isDetected(target, baseDir) {
+  return target.detect.some((sig) => existsSync(path.join(baseDir, sig)));
+}
+
+export async function installSkill(options = {}) {
+  p.intro(chalk.bold('spec-wave install-skill'));
+
+  if (!existsSync(SKILL_SOURCE)) {
+    p.log.error(`SKILL.md não encontrado no pacote (${SKILL_SOURCE}).`);
+    process.exitCode = 1;
+    return;
+  }
+  const raw = readFileSync(SKILL_SOURCE, 'utf-8');
+  const parsed = parseSkill(raw);
+
+  const isGlobal = !!options.global;
+  const baseDir = isGlobal ? homedir() : process.cwd();
+  const scopeLabel = isGlobal ? 'global (usuário)' : 'projeto (local)';
+
+  // 1) Determinar quais agentes receberão a skill.
+  let selectedKeys;
+  if (options.agent) {
+    const requested = String(options.agent)
+      .split(',')
+      .map((s) => s.trim().toLowerCase())
+      .filter(Boolean);
+    const invalid = requested.filter((k) => !TARGET_BY_KEY.has(k));
+    if (invalid.length) {
+      p.log.error(
+        `Agente(s) inválido(s): ${invalid.join(', ')}.\n` +
+          `Válidos: ${TARGETS.map((t) => t.key).join(', ')}.`,
+      );
+      process.exitCode = 1;
+      return;
+    }
+    selectedKeys = requested;
+  } else {
+    const detected = TARGETS.filter((t) => isDetected(t, baseDir)).map((t) => t.key);
+
+    if (options.all) {
+      if (!detected.length) {
+        p.log.error(
+          `Nenhum agente detectado em ${scopeLabel}. Use --agent <nome> para escolher manualmente.`,
+        );
+        process.exitCode = 1;
+        return;
+      }
+      selectedKeys = detected;
+    } else if (options.yes) {
+      if (!detected.length) {
+        p.log.error(
+          `Nenhum agente detectado em ${scopeLabel}. Use --agent <nome> em modo não-interativo.`,
+        );
+        process.exitCode = 1;
+        return;
+      }
+      selectedKeys = detected;
+    } else {
+      const answer = await p.multiselect({
+        message: `Onde instalar a skill? (escopo: ${scopeLabel})`,
+        options: TARGETS.map((t) => ({
+          value: t.key,
+          label: t.name,
+          hint: isDetected(t, baseDir) ? 'detectado' : undefined,
+        })),
+        initialValues: detected,
+        required: true,
+      });
+      if (p.isCancel(answer)) {
+        p.cancel('Instalação cancelada.');
+        return;
+      }
+      selectedKeys = answer;
+    }
+  }
+
+  // 2) Resolver destinos, avisando sobre escopos não suportados.
+  const jobs = [];
+  for (const key of selectedKeys) {
+    const target = TARGET_BY_KEY.get(key);
+    const dest = resolveDest(target, baseDir, isGlobal);
+    if (!dest) {
+      p.log.warn(`${target.name}: escopo global não suportado — pulado.`);
+      continue;
+    }
+    jobs.push({ target, dest });
+  }
+
+  if (!jobs.length) {
+    p.log.warn('Nenhum destino a instalar.');
+    p.outro('Nada foi feito.');
+    return;
+  }
+
+  // 3) Dry-run: apenas listar.
+  if (options.dryRun) {
+    p.note(
+      jobs
+        .map((j) => `${chalk.dim(j.target.name.padEnd(20))} ${j.dest.path}  ${chalk.dim(`(${j.dest.format})`)}`)
+        .join('\n'),
+      `Dry-run — nada será gravado (escopo: ${scopeLabel})`,
+    );
+    p.outro('Dry-run concluído.');
+    return;
+  }
+
+  // 4) Gravar cada destino.
+  const written = [];
+  for (const { target, dest } of jobs) {
+    const content =
+      dest.format === 'agents'
+        ? mergeAgentsFile(dest.path, renderContent('agents', raw, parsed))
+        : renderContent(dest.format, raw, parsed);
+
+    // Confirmar sobrescrita de arquivos "próprios" (skill/rules/mdc). Para
+    // 'agents' o merge por marcadores já é seguro (não apaga conteúdo alheio).
+    if (existsSync(dest.path) && dest.format !== 'agents' && !options.force && !options.yes) {
+      const ok = await p.confirm({
+        message: `${target.name}: ${dest.path} já existe. Sobrescrever?`,
+        initialValue: true,
+      });
+      if (p.isCancel(ok) || !ok) {
+        p.log.info(`${target.name}: mantido (não sobrescrito).`);
+        continue;
+      }
+    }
+
+    mkdirSync(path.dirname(dest.path), { recursive: true });
+    writeFileSync(dest.path, content, 'utf-8');
+    written.push({ target, dest });
+  }
+
+  if (!written.length) {
+    p.outro('Nada foi gravado.');
+    return;
+  }
+
+  p.note(
+    written.map((w) => `${chalk.green('✓')} ${chalk.bold(w.target.name)}\n  ${chalk.dim(w.dest.path)}`).join('\n'),
+    `Skill instalada (escopo: ${scopeLabel})`,
+  );
+  p.outro('Reinicie/recarregue o agente para que ele detecte a skill.');
+}

package/src/commands/qa.mjs

@@ -64,6 +64,7 @@ async function setQA(token, project, etapaField, statusField, nodeId) {
 
 export async function qa({ prNumber }) {
   const token = await resolveToken();
+  const projectToken = process.env.PROJECT_TOKEN || token;
   const [envOwner, envRepo] = (process.env.GITHUB_REPOSITORY || '').split('/');
   const cfgPath = path.join(process.cwd(), CONFIG_FILE);
   let cfg = {};
@@ -103,8 +104,8 @@ export async function qa({ prNumber }) {
     return;
   }
 
-  const etapaField = await resolveField(token, project, 'Etapa').catch(() => null);
-  const statusField = await resolveField(token, project, 'Status').catch(() => null);
+  const etapaField = await resolveField(projectToken, project, 'Etapa').catch(() => null);
+  const statusField = await resolveField(projectToken, project, 'Status').catch(() => null);
 
   const seen = new Set();
   const updated = [];
@@ -114,7 +115,7 @@ export async function qa({ prNumber }) {
     if (!feature || seen.has(feature.number)) continue;
     seen.add(feature.number);
     try {
-      await setQA(token, project, etapaField, statusField, feature.node_id);
+      await setQA(projectToken, project, etapaField, statusField, feature.node_id);
       updated.push(`#${feature.number} ${feature.title}`);
       console.log(`Feature #${feature.number} → "${QA_STAGE}" / Status "${TODO_STATUS}".`);
     } catch (err) {