@spec-wave/cli 0.1.0

package/bin/spec-wave.mjs

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+
+import { program } from 'commander';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import { readFileSync } from 'node:fs';
+
+const __dir = path.dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(path.join(__dir, '..', 'package.json'), 'utf-8'));
+
+program
+  .name('spec-wave')
+  .description('Setup spec-driven GitHub workflow with Projects v2')
+  .version(pkg.version);
+
+program
+  .command('init')
+  .description('Configura spec-wave em um repositório GitHub')
+  .option('--dry-run', 'Simula a configuração sem fazer alterações')
+  .option('--repo <owner/repo>', 'Repositório GitHub (ignora o wizard interativo)')
+  .option('--project-title <title>', 'Nome do GitHub Project (padrão: "<repo> — Spec Wave")')
+  .option('--skip-project', 'Pula a criação do GitHub Project (use se já foi criado)')
+  .option('--skip-labels', 'Pula a criação das labels')
+  .option('--skip-files', 'Pula a criação dos arquivos de workflow')
+  .action(async (options) => {
+    const { init } = await import('../src/commands/init.mjs');
+    await init(options);
+  });
+
+program
+  .command('info')
+  .description('Mostra se o repositório atual foi inicializado e os dados do .spec-wave.json')
+  .option('--json', 'Saída em JSON (para uso programático)')
+  .action(async (options) => {
+    const { info } = await import('../src/commands/info.mjs');
+    await info(options);
+  });
+
+program
+  .command('refresh')
+  .description('Atualiza o .spec-wave.json local com os dados atuais do GitHub Project')
+  .option('--config', 'Re-consulta o Project e reescreve o .spec-wave.json')
+  .action(async (options) => {
+    const { refresh } = await import('../src/commands/refresh.mjs');
+    await refresh(options).catch(err => { console.error(err.message); process.exit(1); });
+  });
+
+program
+  .command('issue')
+  .description('Cria um work item (epic/feature/story/task...), opcionalmente como sub-issue, e adiciona ao board')
+  .requiredOption('--title <title>', 'Título (sem o prefixo de tipo, ex.: [FEATURE])')
+  .option('--type <type>', 'Tipo: epic, feature, story, task, bug, spike ou rfc', 'feature')
+  .option('--parent <n>', 'Número da issue pai (cria como sub-issue dela)')
+  .option('--body <text>', 'Descrição')
+  .option('--priority <p>', 'Prioridade: P0, P1, P2 ou P3')
+  .option('--area <area>', 'Área: Frontend, Backend, Mobile, Infra, DevOps ou Data')
+  .action(async (options) => {
+    const { issue } = await import('../src/commands/issue.mjs');
+    await issue(options).catch(err => { console.error(err.message); process.exit(1); });
+  });
+
+program
+  .command('feature')
+  .description('Atalho de `issue --type feature`')
+  .requiredOption('--title <title>', 'Título da feature (sem o prefixo [FEATURE])')
+  .option('--parent <n>', 'Número da Epic pai (cria como sub-issue dela)')
+  .option('--body <text>', 'Descrição da feature')
+  .option('--priority <p>', 'Prioridade: P0, P1, P2 ou P3 (adiciona label)')
+  .option('--area <area>', 'Área: Frontend, Backend, Mobile, Infra, DevOps ou Data')
+  .action(async (options) => {
+    const { feature } = await import('../src/commands/feature.mjs');
+    await feature(options).catch(err => { console.error(err.message); process.exit(1); });
+  });
+
+program
+  .command('uninstall')
+  .description('Remove labels, arquivos .github e o .spec-wave.json (mantém o GitHub Project)')
+  .option('--repo <owner/repo>', 'Repositório (padrão: lê do .spec-wave.json)')
+  .option('--skip-labels', 'Não remove as labels')
+  .option('--skip-files', 'Não remove os arquivos .github')
+  .option('--keep-config', 'Mantém o .spec-wave.json local')
+  .option('--dry-run', 'Mostra o que seria removido sem alterar nada')
+  .option('--yes', 'Não pede confirmação')
+  .action(async (options) => {
+    const { uninstall } = await import('../src/commands/uninstall.mjs');
+    await uninstall(options).catch(err => { console.error(err.message); process.exit(1); });
+  });
+
+program
+  .command('generate-plan')
+  .description('Gera plan.md para uma Feature (usado pelo GitHub Action)')
+  .requiredOption('--issue-number <n>', 'Número da issue no GitHub')
+  .action(async (options) => {
+    const { generatePlan } = await import('../src/commands/generate-plan.mjs');
+    await generatePlan(options).catch(err => { console.error(err.message); process.exit(1); });
+  });
+
+program
+  .command('generate-spec')
+  .description('Gera spec.md para uma Feature (usado pelo GitHub Action)')
+  .requiredOption('--issue-number <n>', 'Número da issue no GitHub')
+  .action(async (options) => {
+    const { generateSpec } = await import('../src/commands/generate-spec.mjs');
+    await generateSpec(options).catch(err => { console.error(err.message); process.exit(1); });
+  });
+
+program
+  .command('validate')
+  .description('Valida spec.md e plan.md de uma Feature (usado pelo GitHub Action)')
+  .requiredOption('--issue-number <n>', 'Número da issue no GitHub')
+  .action(async (options) => {
+    const { validate } = await import('../src/commands/validate.mjs');
+    await validate(options).catch(err => { console.error(err.message); process.exit(1); });
+  });
+
+program
+  .command('decompose')
+  .description('Decompõe uma Feature em Stories e Tasks (usado pelo GitHub Action)')
+  .requiredOption('--issue-number <n>', 'Número da issue no GitHub')
+  .action(async (options) => {
+    const { decompose } = await import('../src/commands/decompose.mjs');
+    await decompose(options).catch(err => { console.error(err.message); process.exit(1); });
+  });
+
+program.parse();

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@spec-wave/cli",
+  "version": "0.1.0",
+  "description": "Setup spec-driven GitHub workflow with Projects v2, labels, issue templates, and AI-powered Actions",
+  "type": "module",
+  "bin": {
+    "spec-wave": "./bin/spec-wave.mjs"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "bin",
+    "src"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.36.3",
+    "@clack/prompts": "^0.9.1",
+    "@octokit/graphql": "^9.0.1",
+    "@octokit/rest": "^22.0.0",
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0"
+  }
+}

package/src/api/auth.mjs

@@ -0,0 +1,36 @@
+import { execSync } from 'node:child_process';
+
+export async function resolveToken() {
+  if (process.env.GITHUB_TOKEN) return process.env.GITHUB_TOKEN;
+  if (process.env.GH_TOKEN) return process.env.GH_TOKEN;
+  try {
+    const token = execSync('gh auth token', { stdio: ['pipe', 'pipe', 'pipe'] })
+      .toString()
+      .trim();
+    if (token) return token;
+  } catch {
+    // gh not installed or not authenticated
+  }
+  throw new Error(
+    'GitHub token not found.\n' +
+    'Set GITHUB_TOKEN or GH_TOKEN environment variable, or run: gh auth login'
+  );
+}
+
+export async function verifyTokenScopes(token) {
+  const { Octokit } = await import('@octokit/rest');
+  const octokit = new Octokit({ auth: token });
+  try {
+    const response = await octokit.request('GET /user');
+    const scopes = response.headers['x-oauth-scopes'] || '';
+    const scopeList = scopes.split(',').map(s => s.trim());
+    const hasProject = scopeList.includes('project') || scopeList.includes('read:project');
+    // `repo` covers private repos; `public_repo` covers public-only repos
+    const hasRepo = scopeList.includes('repo') || scopeList.includes('public_repo');
+    // `workflow` is required to create/update files under .github/workflows/
+    const hasWorkflow = scopeList.includes('workflow');
+    return { login: response.data.login, hasProject, hasRepo, hasWorkflow, scopes: scopeList };
+  } catch (err) {
+    throw new Error(`Token verification failed: ${err.message}`);
+  }
+}

package/src/api/github-graphql.mjs

@@ -0,0 +1,238 @@
+import { graphql } from '@octokit/graphql';
+
+function makeClient(token) {
+  return graphql.defaults({
+    headers: { authorization: `token ${token}` },
+  });
+}
+
+export async function createProject(token, ownerId, title) {
+  const client = makeClient(token);
+  const result = await client(`
+    mutation CreateProject($ownerId: ID!, $title: String!) {
+      createProjectV2(input: { ownerId: $ownerId, title: $title }) {
+        projectV2 {
+          id
+          number
+          url
+          fields(first: 20) {
+            nodes {
+              ... on ProjectV2SingleSelectField {
+                id
+                name
+              }
+            }
+          }
+        }
+      }
+    }
+  `, { ownerId, title });
+
+  const project = result.createProjectV2.projectV2;
+  const statusField = project.fields.nodes.find(f => f.name === 'Status');
+  return { projectId: project.id, projectNumber: project.number, projectUrl: project.url, statusFieldId: statusField?.id };
+}
+
+export async function updateStatusField(token, fieldId, options) {
+  const client = makeClient(token);
+  await client(`
+    mutation UpdateStatusField($fieldId: ID!, $options: [ProjectV2SingleSelectFieldOptionInput!]!) {
+      updateProjectV2Field(input: {
+        fieldId: $fieldId
+        singleSelectOptions: $options
+      }) {
+        projectV2Field {
+          ... on ProjectV2SingleSelectField {
+            id
+            name
+          }
+        }
+      }
+    }
+  `, {
+    fieldId,
+    options: options.map(o => ({ name: o.name, color: o.color, description: '' })),
+  });
+}
+
+export async function createSingleSelectField(token, projectId, name, options) {
+  const client = makeClient(token);
+  const result = await client(`
+    mutation CreateField($projectId: ID!, $name: String!, $options: [ProjectV2SingleSelectFieldOptionInput!]!) {
+      createProjectV2Field(input: {
+        projectId: $projectId
+        dataType: SINGLE_SELECT
+        name: $name
+        singleSelectOptions: $options
+      }) {
+        projectV2Field {
+          ... on ProjectV2SingleSelectField {
+            id
+            name
+            options { id name }
+          }
+        }
+      }
+    }
+  `, {
+    projectId,
+    name,
+    options: options.map(o => ({ name: o.name, color: o.color, description: o.description || '' })),
+  });
+  const field = result.createProjectV2Field.projectV2Field;
+  const optionIds = {};
+  for (const o of field.options) optionIds[o.name] = o.id;
+  return { id: field.id, options: optionIds };
+}
+
+// Lê um campo SINGLE_SELECT existente (id + mapa nome→id das opções). Usado pelo
+// comando `feature` como fallback quando o .spec-wave.json não traz os IDs.
+export async function getSingleSelectField(token, projectId, fieldName) {
+  const client = makeClient(token);
+  const result = await client(`
+    query GetField($projectId: ID!) {
+      node(id: $projectId) {
+        ... on ProjectV2 {
+          fields(first: 50) {
+            nodes {
+              ... on ProjectV2SingleSelectField {
+                id
+                name
+                options { id name }
+              }
+            }
+          }
+        }
+      }
+    }
+  `, { projectId });
+  const field = result.node.fields.nodes.find(f => f && f.name === fieldName);
+  if (!field) return null;
+  const optionIds = {};
+  for (const o of field.options) optionIds[o.name] = o.id;
+  return { id: field.id, options: optionIds };
+}
+
+// Lê os metadados atuais de um Project (id, number, url, title) + o campo "Etapa"
+// (id e opções), em uma única query. Usado pelo comando `refresh`.
+export async function getProjectSnapshot(token, projectId) {
+  const client = makeClient(token);
+  const result = await client(`
+    query Snapshot($projectId: ID!) {
+      node(id: $projectId) {
+        ... on ProjectV2 {
+          id
+          number
+          url
+          title
+          fields(first: 50) {
+            nodes {
+              ... on ProjectV2SingleSelectField {
+                id
+                name
+                options { id name }
+              }
+            }
+          }
+        }
+      }
+    }
+  `, { projectId });
+  const project = result.node;
+  if (!project) return null;
+  // Mapa nome → {id, options{nome→id}} de todos os campos single-select do Project.
+  const fields = {};
+  for (const f of project.fields.nodes) {
+    if (!f || !f.name || !f.options) continue;
+    const options = {};
+    for (const o of f.options) options[o.name] = o.id;
+    fields[f.name] = { id: f.id, options };
+  }
+  return {
+    id: project.id,
+    number: project.number,
+    url: project.url,
+    title: project.title,
+    fields,
+  };
+}
+
+// Adiciona uma issue/PR (pelo node id do conteúdo) ao Project. Retorna o id do item criado.
+export async function addProjectItem(token, projectId, contentId) {
+  const client = makeClient(token);
+  const result = await client(`
+    mutation AddItem($projectId: ID!, $contentId: ID!) {
+      addProjectV2ItemById(input: { projectId: $projectId, contentId: $contentId }) {
+        item { id }
+      }
+    }
+  `, { projectId, contentId });
+  return result.addProjectV2ItemById.item.id;
+}
+
+// Cria a relação de sub-issue nativa do GitHub (parent → child). Ambos os IDs
+// são node ids de Issue. Faz com que o filho exiba o pai e vice-versa na UI.
+export async function addSubIssue(token, parentIssueId, childIssueId) {
+  const client = makeClient(token);
+  await client(`
+    mutation AddSubIssue($issueId: ID!, $subIssueId: ID!) {
+      addSubIssue(input: { issueId: $issueId, subIssueId: $subIssueId }) {
+        subIssue { id number }
+      }
+    }
+  `, { issueId: parentIssueId, subIssueId: childIssueId });
+}
+
+// Define o valor de um campo SINGLE_SELECT para um item do Project.
+export async function setItemSingleSelect(token, projectId, itemId, fieldId, optionId) {
+  const client = makeClient(token);
+  await client(`
+    mutation SetField($projectId: ID!, $itemId: ID!, $fieldId: ID!, $optionId: String!) {
+      updateProjectV2ItemFieldValue(input: {
+        projectId: $projectId
+        itemId: $itemId
+        fieldId: $fieldId
+        value: { singleSelectOptionId: $optionId }
+      }) {
+        projectV2Item { id }
+      }
+    }
+  `, { projectId, itemId, fieldId, optionId });
+}
+
+export async function createTextField(token, projectId, name) {
+  const client = makeClient(token);
+  const result = await client(`
+    mutation CreateTextField($projectId: ID!, $name: String!) {
+      createProjectV2Field(input: {
+        projectId: $projectId
+        dataType: TEXT
+        name: $name
+      }) {
+        projectV2Field {
+          ... on ProjectV2Field {
+            id
+            name
+          }
+        }
+      }
+    }
+  `, { projectId, name });
+  return result.createProjectV2Field.projectV2Field.id;
+}
+
+export async function linkProjectToRepo(token, projectId, repositoryId) {
+  const client = makeClient(token);
+  await client(`
+    mutation LinkProject($projectId: ID!, $repositoryId: ID!) {
+      linkProjectV2ToRepository(input: {
+        projectId: $projectId
+        repositoryId: $repositoryId
+      }) {
+        repository {
+          id
+        }
+      }
+    }
+  `, { projectId, repositoryId });
+}

package/src/api/github-rest.mjs

@@ -0,0 +1,157 @@
+import { Octokit } from '@octokit/rest';
+
+function makeOctokit(token) {
+  return new Octokit({ auth: token });
+}
+
+export async function getOwnerNodeId(token, owner) {
+  const octokit = makeOctokit(token);
+  try {
+    const res = await octokit.rest.orgs.get({ org: owner });
+    return res.data.node_id;
+  } catch {
+    const res = await octokit.rest.users.getByUsername({ username: owner });
+    return res.data.node_id;
+  }
+}
+
+export async function getRepoNodeId(token, owner, repo) {
+  const octokit = makeOctokit(token);
+  const res = await octokit.rest.repos.get({ owner, repo });
+  return res.data.node_id;
+}
+
+export async function getRepoDefaultBranch(token, owner, repo) {
+  const octokit = makeOctokit(token);
+  const res = await octokit.rest.repos.get({ owner, repo });
+  return res.data.default_branch;
+}
+
+export async function createLabel(token, owner, repo, label) {
+  const octokit = makeOctokit(token);
+  try {
+    await octokit.rest.issues.createLabel({
+      owner,
+      repo,
+      name: label.name,
+      color: label.color,
+      description: label.description,
+    });
+  } catch (err) {
+    // 422 = label already exists, skip
+    if (err.status !== 422) throw err;
+  }
+}
+
+export async function upsertFile(token, owner, repo, path, content, message) {
+  const octokit = makeOctokit(token);
+  let sha;
+  try {
+    const existing = await octokit.rest.repos.getContent({ owner, repo, path });
+    sha = existing.data.sha;
+  } catch {
+    // file doesn't exist yet
+  }
+  await octokit.rest.repos.createOrUpdateFileContents({
+    owner,
+    repo,
+    path,
+    message,
+    content: Buffer.from(content).toString('base64'),
+    ...(sha ? { sha } : {}),
+  });
+}
+
+export async function createIssue(token, owner, repo, title, body, labels) {
+  const octokit = makeOctokit(token);
+  const res = await octokit.rest.issues.create({ owner, repo, title, body, labels });
+  return { number: res.data.number, nodeId: res.data.node_id, url: res.data.html_url };
+}
+
+export async function getIssue(token, owner, repo, issueNumber) {
+  const octokit = makeOctokit(token);
+  const res = await octokit.rest.issues.get({ owner, repo, issue_number: issueNumber });
+  return res.data;
+}
+
+export async function deleteLabel(token, owner, repo, name) {
+  const octokit = makeOctokit(token);
+  try {
+    await octokit.rest.issues.deleteLabel({ owner, repo, name });
+    return true;
+  } catch (err) {
+    if (err.status === 404) return false; // label já não existe
+    throw err;
+  }
+}
+
+export async function deleteFile(token, owner, repo, filePath, message) {
+  const octokit = makeOctokit(token);
+  let sha;
+  try {
+    const existing = await octokit.rest.repos.getContent({ owner, repo, path: filePath });
+    sha = existing.data.sha;
+  } catch (err) {
+    if (err.status === 404) return false; // arquivo já não existe
+    throw err;
+  }
+  await octokit.rest.repos.deleteFile({ owner, repo, path: filePath, message, sha });
+  return true;
+}
+
+export async function addLabel(token, owner, repo, issueNumber, labelName) {
+  const octokit = makeOctokit(token);
+  await octokit.rest.issues.addLabels({
+    owner,
+    repo,
+    issue_number: issueNumber,
+    labels: [labelName],
+  });
+}
+
+export async function removeLabel(token, owner, repo, issueNumber, labelName) {
+  const octokit = makeOctokit(token);
+  try {
+    await octokit.rest.issues.removeLabel({
+      owner,
+      repo,
+      issue_number: issueNumber,
+      name: labelName,
+    });
+  } catch (err) {
+    if (err.status !== 404) throw err;
+  }
+}
+
+export async function commentOnIssue(token, owner, repo, issueNumber, body) {
+  const octokit = makeOctokit(token);
+  await octokit.rest.issues.createComment({
+    owner,
+    repo,
+    issue_number: issueNumber,
+    body,
+  });
+}
+
+export async function isRepoInitialized(token, owner, repo) {
+  const octokit = makeOctokit(token);
+  try {
+    await octokit.rest.repos.listCommits({ owner, repo, per_page: 1 });
+    return true;
+  } catch (err) {
+    // GitHub returns 409 "Git Repository is empty" for repos with no commits
+    if (err.status === 409 || err.status === 404) return false;
+    throw err;
+  }
+}
+
+export async function getFileContent(token, owner, repo, path) {
+  const octokit = makeOctokit(token);
+  try {
+    const res = await octokit.rest.repos.getContent({ owner, repo, path });
+    return Buffer.from(res.data.content, 'base64').toString('utf-8');
+  } catch (err) {
+    if (err.status === 404) return null;
+    throw err;
+  }
+}

package/src/commands/decompose.mjs

@@ -0,0 +1,113 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { resolveToken } from '../api/auth.mjs';
+import { getIssue, removeLabel, commentOnIssue } from '../api/github-rest.mjs';
+import { generateDocument } from '../lib/claude.mjs';
+import { slugify } from '../lib/slugify.mjs';
+
+const SYSTEM_PROMPT = `Você é um Tech Lead experiente em decomposição de trabalho ágil.
+A partir da Feature fornecida (com spec.md e plan.md), gere uma lista de Stories e Tasks.
+
+Responda APENAS com JSON válido neste formato:
+{
+  "stories": [
+    {
+      "title": "[STORY] Título da story no formato 'Como <perfil>, quero <objetivo>, para <benefício>'",
+      "body": "Descrição da story com contexto e critérios de aceite relevantes",
+      "tasks": [
+        {
+          "title": "[TASK] Título técnico da task",
+          "body": "Descrição técnica detalhada"
+        }
+      ]
+    }
+  ]
+}
+
+Regras:
+- Cada Story deve ter 2–5 Tasks associadas
+- Stories devem seguir o formato de User Story
+- Tasks devem ser atividades técnicas concretas
+- Gere entre 3 e 7 Stories por Feature`;
+
+export async function decompose({ issueNumber }) {
+  const token = await resolveToken();
+  const [owner, repo] = (process.env.GITHUB_REPOSITORY || '').split('/');
+
+  if (!owner || !repo) {
+    throw new Error(
+      'GITHUB_REPOSITORY env var não definida.\n' +
+      'Este comando roda no GitHub Actions. Para testar localmente:\n' +
+      '  GITHUB_REPOSITORY=owner/repo spec-wave decompose --issue-number 1'
+    );
+  }
+
+  const issue = await getIssue(token, owner, repo, parseInt(issueNumber, 10));
+  const slug = slugify(issue.title);
+  const featureDir = `docs/features/${slug}`;
+
+  const planContent = existsSync(`${featureDir}/plan.md`)
+    ? readFileSync(`${featureDir}/plan.md`, 'utf-8')
+    : '(plan.md não encontrado)';
+
+  const specContent = existsSync(`${featureDir}/spec.md`)
+    ? readFileSync(`${featureDir}/spec.md`, 'utf-8')
+    : '(spec.md não encontrado)';
+
+  console.log(`Decompondo feature: ${issue.title}`);
+
+  const userContent = [
+    `Feature: ${issue.title}`,
+    `Issue #${issueNumber}`,
+    `\n## spec.md\n${specContent}`,
+    `\n## plan.md\n${planContent}`,
+  ].join('\n');
+
+  const raw = await generateDocument(SYSTEM_PROMPT, userContent);
+
+  let decomposition;
+  try {
+    decomposition = JSON.parse(raw);
+  } catch {
+    // Try to extract JSON from the response
+    const jsonMatch = raw.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) throw new Error('Claude did not return valid JSON');
+    decomposition = JSON.parse(jsonMatch[0]);
+  }
+
+  const created = [];
+
+  for (const story of decomposition.stories) {
+    console.log(`Criando story: ${story.title}`);
+    const storyOutput = execFileSync(
+      'gh',
+      ['issue', 'create', '--title', story.title, '--body', story.body, '--label', '[STORY]'],
+      { encoding: 'utf-8' }
+    ).trim();
+    const storyUrl = storyOutput.trim();
+    created.push({ type: 'story', title: story.title, url: storyUrl });
+
+    for (const task of story.tasks || []) {
+      console.log(`  Criando task: ${task.title}`);
+      const taskBody = `${task.body}\n\n_Story pai: ${storyUrl}_`;
+      execFileSync(
+        'gh',
+        ['issue', 'create', '--title', task.title, '--body', taskBody, '--label', '[TASK]'],
+        { encoding: 'utf-8' }
+      );
+    }
+  }
+
+  // Remove trigger label
+  await removeLabel(token, owner, repo, parseInt(issueNumber, 10), 'spec-wave:decompose');
+
+  const storyList = created.map(s => `- ${s.url} — ${s.title}`).join('\n');
+  await commentOnIssue(
+    token, owner, repo, parseInt(issueNumber, 10),
+    `🔀 **Decomposição concluída!**\n\n` +
+    `Foram criados ${decomposition.stories.length} stories e suas tasks:\n\n${storyList}\n\n` +
+    `Mova o card para **📋 Backlog Técnico** para iniciar o desenvolvimento.`
+  );
+
+  console.log(`Decomposição concluída: ${decomposition.stories.length} stories criadas.`);
+}