@brunosps00/dev-workflow 0.0.3

package/README.md

@@ -0,0 +1,156 @@
+# dev-workflow
+
+AI-driven development workflow commands for any project. Scaffolds a complete PRD-to-PR pipeline with multi-platform AI assistant support.
+
+## Install
+
+```bash
+npx @brunosps00/dev-workflow init
+```
+
+This will:
+1. Ask you to select a language (English or Portuguese)
+2. Create `ai/commands/` with 17 workflow commands
+3. Create `ai/templates/` with document templates
+4. Create `ai/rules/` (populated by `/analyze-project`)
+5. Generate skill wrappers for Claude Code, Codex, Copilot, and OpenCode
+6. Configure MCP servers (Context7 + Playwright)
+
+## Commands
+
+### Planning
+
+#### `/brainstorm`
+Facilitates structured ideation before opening a PRD or implementation. Explores multiple directions — conservative, balanced, and bold — with trade-offs for each, then converges on concrete next steps. No code is written or files modified.
+
+#### `/create-prd`
+Creates a Product Requirements Document by first asking at least 7 clarification questions to fully understand the feature. Generates a structured PRD with numbered functional requirements focused on what and why, saved to `ai/spec/prd-[feature-name]/prd.md`.
+
+#### `/create-techspec`
+Generates a Technical Specification from an existing PRD after performing web searches and asking at least 7 clarification questions. Evaluates existing libraries vs custom development, defines testing strategy, branch naming, and integration architecture. Output is saved to `ai/spec/prd-[feature-name]/techspec.md`.
+
+#### `/create-tasks`
+Breaks down the PRD and TechSpec into implementable tasks with a target of ~6 tasks per feature (max 2 functional requirements each). Creates individual task files with subtasks and success criteria, ensuring end-to-end coverage across backend, frontend, and functional UI. Requires approval before finalizing.
+
+### Execution
+
+#### `/run-task`
+Executes a single task from the task list, implementing code that follows project patterns and includes mandatory unit tests. Performs Level 1 validation (acceptance criteria + tests + standards check) and creates a commit upon completion.
+
+#### `/run-plan`
+Executes all pending tasks sequentially and automatically, with Level 1 validation after each task. After all tasks are complete, performs a final Level 2 review (PRD compliance) with an interactive corrections cycle until no gaps remain or the user accepts pending items.
+
+#### `/bugfix`
+Analyzes and fixes bugs with automatic triage that distinguishes between bugs, feature requests, and excessive scope. Asks exactly 3 clarification questions before proposing a solution. Supports Direct mode (executes fix immediately) and Analysis mode (`--analysis`) that generates a document for the techspec/tasks pipeline.
+
+### Quality
+
+#### `/run-qa`
+Validates the implementation against PRD, TechSpec, and Tasks using Playwright MCP for E2E browser automation. Tests happy paths, edge cases, negative flows, and regressions while verifying WCAG 2.2 accessibility compliance. Generates a QA report, documents bugs with screenshot evidence, and detects stub/placeholder pages.
+
+#### `/fix-qa`
+Fixes bugs found during QA testing with evidence-driven retesting via Playwright MCP. Runs iterative cycles of identify → fix → retest, updating `QA/bugs.md` and `QA/qa-report.md` with status and retest evidence including screenshots and logs.
+
+#### `/review-implementation`
+Compares documented requirements (PRD + TechSpec + Tasks) against actual code as a Level 2 review. Maps each requirement to endpoints and tasks with evidence, identifies gaps, partial implementations, and extra undocumented code. Does not execute fixes — waits for user instruction.
+
+#### `/code-review`
+Performs a formal Level 3 code review before PR creation, verifying PRD compliance, code quality (SOLID, DRY, complexity, security), and conformance with project rules in `ai/rules/`. Runs tests, verifies coverage targets, and generates a persistent report with APPROVED, APPROVED WITH CAVEATS, or REJECTED status.
+
+#### `/refactoring-analysis`
+Audits the codebase for code smells and refactoring opportunities using Martin Fowler's catalog. Detects bloaters, change preventers, dispensables, couplers, conditional complexity, and DRY violations, then maps each to a concrete refactoring technique with before/after code sketches. Includes coupling/cohesion metrics, SOLID analysis, and a prioritized action plan (P0-P3).
+
+### Git & PR
+
+#### `/commit`
+Analyzes pending changes, groups them by feature or logical context, and creates atomic semantic commits following the Conventional Commits format. Uses allowed types: `feat`, `fix`, `docs`, `style`, `refactor`, `perf`, `test`, `chore`, `ci`, `build`.
+
+#### `/generate-pr`
+Pushes the branch to remote and creates a Pull Request on GitHub with a structured description. Collects information from the PRD and modified files, runs tests, then generates a PR body with summary, changes grouped by module, test plan, and deploy notes.
+
+### Utilities
+
+#### `/analyze-project`
+Scans the repository to identify tech stack, architectural patterns, naming conventions, and anti-patterns. Generates structured documentation in `ai/rules/` with a project overview (`index.md`) and per-module rule files containing real code examples, which are consumed by other workflow commands.
+
+#### `/deep-research`
+Conducts multi-source research with citation tracking and verification across quick, standard, deep, and ultradeep modes. Executes parallel information gathering, triangulation, and cross-reference verification through 8+ phases, producing a professional report with complete bibliography.
+
+#### `/help`
+Displays the complete guide of available commands, integration flows, and when to use each one. Can be invoked without arguments for the full guide or with a specific command name (e.g., `/help create-prd`) for a detailed section.
+
+## Workflow
+
+```
+/brainstorm
+    |
+/create-prd  -->  ai/spec/prd-{name}/prd.md
+    |
+/create-techspec  -->  ai/spec/prd-{name}/techspec.md
+    |
+/create-tasks  -->  ai/spec/prd-{name}/tasks.md + {N}_task.md
+    |
+/run-task (or /run-plan for all)
+    |
+/run-qa  -->  ai/spec/prd-{name}/QA/
+    |
+/fix-qa (if bugs found)
+    |
+/review-implementation  -->  PRD compliance check
+    |
+/refactoring-analysis  -->  ai/spec/prd-{name}/refactoring-analysis.md (optional)
+    |
+/code-review  -->  ai/spec/prd-{name}/QA/code-review.md
+    |
+/commit + /generate-pr
+```
+
+## Platform Support
+
+| Platform | Wrapper Location | Status |
+|----------|-----------------|--------|
+| Claude Code | `.claude/skills/` | Full support |
+| Codex CLI | `.codex/skills/` | Full support |
+| Copilot | `.agents/skills/` | Full support |
+| OpenCode | `.agents/skills/` | Full support |
+
+All wrappers point to `ai/commands/` as the single source of truth.
+
+## Project Structure (after init)
+
+```
+your-project/
+├── ai/
+│   ├── commands/          # 16 workflow command files
+│   ├── templates/         # Document templates (PRD, TechSpec, etc.)
+│   ├── rules/             # Project-specific rules (run /analyze-project)
+│   └── spec/              # PRD directories created by commands
+├── .claude/
+│   ├── skills/            # Claude Code wrappers
+│   └── settings.json      # MCP servers (Context7, Playwright)
+├── .codex/skills/         # Codex CLI wrappers
+└── .agents/skills/        # Copilot/OpenCode wrappers
+```
+
+## Options
+
+```bash
+npx @brunosps00/dev-workflow init                  # Interactive language selection
+npx @brunosps00/dev-workflow init --lang=en        # English, skip prompt
+npx @brunosps00/dev-workflow init --lang=pt-br     # Portuguese, skip prompt
+npx @brunosps00/dev-workflow init --force          # Overwrite existing files
+npx @brunosps00/dev-workflow update                # Update commands/templates only
+npx @brunosps00/dev-workflow help                  # Show help
+```
+
+## Getting Started
+
+After running `npx @brunosps00/dev-workflow init`:
+
+1. **Run `/analyze-project`** in your AI assistant to generate project rules
+2. **Run `/brainstorm`** to start planning a new feature
+3. **Run `/help`** to see all available commands and workflows
+
+## License
+
+MIT

package/bin/dev-workflow.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+
+const { run } = require('../lib/init');
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+const flags = {};
+for (const arg of args) {
+  if (arg.startsWith('--')) {
+    const [key, value] = arg.slice(2).split('=');
+    flags[key] = value || true;
+  }
+}
+
+const HELP_TEXT = `
+  dev-workflow - AI-driven development workflow commands
+
+  Usage:
+    npx dev-workflow init [--force] [--lang=en|pt-br]
+    npx dev-workflow update [--force]
+    npx dev-workflow help
+
+  Commands:
+    init      Scaffold ai/commands, templates, rules, and platform wrappers
+    update    Update commands and templates (preserves rules and tasks)
+    help      Show this help message
+
+  Options:
+    --force        Overwrite existing files
+    --lang=LANG    Set language without prompt (en or pt-br)
+
+  Examples:
+    npx dev-workflow init                  # Interactive language selection
+    npx dev-workflow init --lang=en        # English, no prompt
+    npx dev-workflow init --lang=pt-br     # Portuguese, no prompt
+    npx dev-workflow init --force          # Overwrite existing files
+`;
+
+async function main() {
+  switch (command) {
+    case 'init':
+      await run({ force: !!flags.force, lang: flags.lang, mode: 'init' });
+      break;
+    case 'update':
+      await run({ force: !!flags.force, lang: flags.lang, mode: 'update' });
+      break;
+    case 'help':
+    case '--help':
+    case '-h':
+    case undefined:
+      console.log(HELP_TEXT);
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      console.log(HELP_TEXT);
+      process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error('Error:', err.message);
+  process.exit(1);
+});

package/lib/constants.js

@@ -0,0 +1,97 @@
+const COMMANDS = {
+  en: [
+    { name: 'analyze-project', description: 'Analyze repository stack, patterns, and conventions to generate project rules' },
+    { name: 'brainstorm', description: 'Explore ideas and directions before starting implementation' },
+    { name: 'bugfix', description: 'Analyze and fix bugs with automatic triage (bug vs feature vs scope)' },
+    { name: 'code-review', description: 'Formal code review (Level 3) with persisted report' },
+    { name: 'commit', description: 'Create semantic commits following Conventional Commits' },
+    { name: 'create-prd', description: 'Create a Product Requirements Document with clarification questions' },
+    { name: 'create-tasks', description: 'Break down PRD and TechSpec into implementable tasks' },
+    { name: 'create-techspec', description: 'Create a Technical Specification from an existing PRD' },
+    { name: 'deep-research', description: 'Conduct multi-source research with citation tracking and verification' },
+    { name: 'fix-qa', description: 'Fix bugs found during QA and retest until stable' },
+    { name: 'generate-pr', description: 'Generate a Pull Request with structured description' },
+    { name: 'help', description: 'Show complete guide of available commands and workflows' },
+    { name: 'refactoring-analysis', description: 'Audit codebase for code smells and refactoring opportunities with prioritized report' },
+    { name: 'review-implementation', description: 'Review if all PRD requirements were correctly implemented' },
+    { name: 'run-plan', description: 'Execute ALL tasks sequentially until the plan is complete' },
+    { name: 'run-qa', description: 'Run visual QA with browser automation, E2E tests, and accessibility' },
+    { name: 'run-task', description: 'Execute a single task with built-in validation and testing' },
+  ],
+  'pt-br': [
+    { name: 'analyze-project', description: 'Analisa stack, patterns e convencoes do repositorio para gerar regras do projeto' },
+    { name: 'brainstorm', description: 'Explorar ideias e direcoes antes de comecar a implementacao' },
+    { name: 'bugfix', description: 'Analisar e corrigir bugs com triagem automatica (bug vs feature vs escopo)' },
+    { name: 'code-review', description: 'Code review formal (Nivel 3) com relatorio persistido' },
+    { name: 'commit', description: 'Criar commits semanticos seguindo Conventional Commits' },
+    { name: 'create-prd', description: 'Criar um Product Requirements Document com perguntas de clarificacao' },
+    { name: 'create-tasks', description: 'Quebrar PRD e TechSpec em tasks implementaveis' },
+    { name: 'create-techspec', description: 'Criar uma Especificacao Tecnica a partir de um PRD existente' },
+    { name: 'deep-research', description: 'Pesquisa multi-fonte com rastreamento de citacoes e verificacao' },
+    { name: 'fix-qa', description: 'Corrigir bugs encontrados no QA e retestar ate estabilizar' },
+    { name: 'generate-pr', description: 'Gerar um Pull Request com descricao estruturada' },
+    { name: 'help', description: 'Mostrar guia completo dos comandos e fluxos disponiveis' },
+    { name: 'refactoring-analysis', description: 'Auditar codebase para code smells e oportunidades de refatoracao com relatorio priorizado' },
+    { name: 'review-implementation', description: 'Revisar se todos os requisitos do PRD foram implementados corretamente' },
+    { name: 'run-plan', description: 'Executar TODAS as tasks sequencialmente ate completar o plano' },
+    { name: 'run-qa', description: 'Executar QA visual com automacao de browser, testes E2E e acessibilidade' },
+    { name: 'run-task', description: 'Executar uma task com validacao e testes integrados' },
+  ],
+};
+
+const PLATFORMS = {
+  claude: {
+    dir: '.claude/skills',
+    wrapperTemplate: (name, description) => `---
+name: ${name}
+description: ${description}
+---
+
+Read and follow ALL instructions in \`ai/commands/${name}.md\`.
+`,
+  },
+  codex: {
+    dir: '.codex/skills',
+    wrapperTemplate: (name, description) => `---
+name: ${name}
+description: Imported from ./ai/commands/${name}.md
+---
+<system_instructions>
+This skill redirects to the project's source command.
+
+Source of truth: \`ai/commands/${name}.md\`
+
+1. Open and read \`ai/commands/${name}.md\` before executing.
+2. Follow the source command entirely.
+3. If divergence exists, the command file prevails.
+</system_instructions>
+`,
+  },
+  agents: {
+    dir: '.agents/skills',
+    wrapperTemplate: (name, description) => `---
+name: ${name}
+description: ${description}
+---
+<system_instructions>
+Source of truth: \`ai/commands/${name}.md\`
+
+Read and follow the complete instructions in the command file above.
+This wrapper exists for tool discovery. All logic lives in ai/commands/.
+</system_instructions>
+`,
+  },
+};
+
+const MCP_SERVERS = {
+  context7: {
+    command: 'npx',
+    args: ['-y', '@upstash/context7-mcp'],
+  },
+  playwright: {
+    command: 'npx',
+    args: ['-y', '@anthropic-ai/mcp-server-playwright'],
+  },
+};
+
+module.exports = { COMMANDS, PLATFORMS, MCP_SERVERS };

package/lib/init.js

@@ -0,0 +1,101 @@
+const path = require('path');
+const { COMMANDS } = require('./constants');
+const { ensureDir, copyDir, writeFile, log } = require('./utils');
+const { selectLanguage } = require('./prompts');
+const { generateWrappers } = require('./wrappers');
+const { installMCPs } = require('./mcp');
+
+const SCAFFOLD_DIR = path.join(__dirname, '..', 'scaffold');
+
+async function run({ force = false, lang = null, mode = 'init' }) {
+  const projectRoot = process.cwd();
+  const isUpdate = mode === 'update';
+
+  console.log(`\n  dev-workflow ${isUpdate ? 'update' : 'init'}`);
+  console.log(`  ${'='.repeat(40)}\n`);
+
+  // 1. Select language
+  const selectedLang = await selectLanguage(lang);
+  console.log(`\n  Language: ${selectedLang}\n`);
+
+  const commands = COMMANDS[selectedLang];
+  const langDir = path.join(SCAFFOLD_DIR, selectedLang);
+
+  // Track totals
+  let totalCreated = 0;
+  let totalSkipped = 0;
+  let totalOverwritten = 0;
+
+  // 2. Copy commands
+  console.log('  Commands:');
+  const cmdResults = copyDir(
+    path.join(langDir, 'commands'),
+    path.join(projectRoot, 'ai', 'commands'),
+    force
+  );
+  totalCreated += cmdResults.created;
+  totalSkipped += cmdResults.skipped;
+  totalOverwritten += cmdResults.overwritten;
+  console.log(`    ${cmdResults.created} created, ${cmdResults.skipped} skipped, ${cmdResults.overwritten} overwritten\n`);
+
+  // 3. Copy templates
+  console.log('  Templates:');
+  const tplResults = copyDir(
+    path.join(langDir, 'templates'),
+    path.join(projectRoot, 'ai', 'templates'),
+    force
+  );
+  totalCreated += tplResults.created;
+  totalSkipped += tplResults.skipped;
+  totalOverwritten += tplResults.overwritten;
+  console.log(`    ${tplResults.created} created, ${tplResults.skipped} skipped, ${tplResults.overwritten} overwritten\n`);
+
+  // 4. Create ai/rules/ with README
+  if (!isUpdate) {
+    console.log('  Rules:');
+    ensureDir(path.join(projectRoot, 'ai', 'rules'));
+    const rulesReadmeSrc = path.join(SCAFFOLD_DIR, 'rules-readme.md');
+    const rulesReadmeDest = path.join(projectRoot, 'ai', 'rules', 'README.md');
+    const status = writeFile(
+      rulesReadmeDest,
+      require('fs').readFileSync(rulesReadmeSrc, 'utf-8'),
+      false
+    );
+    log(status, rulesReadmeDest);
+    if (status === 'created') totalCreated++;
+    else totalSkipped++;
+    console.log();
+  }
+
+  // 5. Create ai/spec/
+  if (!isUpdate) {
+    ensureDir(path.join(projectRoot, 'ai', 'spec'));
+  }
+
+  // 6-8. Generate platform wrappers
+  console.log('  Platform wrappers:');
+  const wrapperResults = generateWrappers(projectRoot, commands, force);
+  totalCreated += wrapperResults.created;
+  totalSkipped += wrapperResults.skipped;
+  totalOverwritten += wrapperResults.overwritten;
+  console.log();
+
+  // 9. Install MCPs
+  if (!isUpdate) {
+    console.log('  MCP Servers:');
+    const mcpResults = installMCPs(projectRoot);
+    console.log(`    ${mcpResults.added} configured, ${mcpResults.skipped} already present\n`);
+  }
+
+  // 10. Summary
+  console.log(`  ${'='.repeat(40)}`);
+  console.log(`  Done! ${totalCreated} created, ${totalSkipped} skipped, ${totalOverwritten} overwritten`);
+  console.log();
+  console.log('  Next steps:');
+  console.log('    1. Run /analyze-project to generate project rules');
+  console.log('    2. Run /brainstorm to start a new feature');
+  console.log('    3. Run /help to see all available commands');
+  console.log();
+}
+
+module.exports = { run };

package/lib/mcp.js

@@ -0,0 +1,40 @@
+const fs = require('fs');
+const path = require('path');
+const { ensureDir } = require('./utils');
+const { MCP_SERVERS } = require('./constants');
+
+function installMCPs(projectRoot) {
+  const settingsPath = path.join(projectRoot, '.claude', 'settings.json');
+  let settings = {};
+
+  if (fs.existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+    } catch {
+      settings = {};
+    }
+  }
+
+  if (!settings.mcpServers) {
+    settings.mcpServers = {};
+  }
+
+  let added = 0;
+  let skipped = 0;
+
+  for (const [name, config] of Object.entries(MCP_SERVERS)) {
+    if (settings.mcpServers[name]) {
+      skipped++;
+    } else {
+      settings.mcpServers[name] = config;
+      added++;
+    }
+  }
+
+  ensureDir(path.dirname(settingsPath));
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+
+  return { added, skipped };
+}
+
+module.exports = { installMCPs };

package/lib/prompts.js

@@ -0,0 +1,36 @@
+const readline = require('readline');
+
+function question(prompt, options) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    const optionsStr = options.map((o, i) => `  ${i + 1}) ${o}`).join('\n');
+    rl.question(`\n${prompt}\n${optionsStr}\n\n  Choose [1-${options.length}]: `, (answer) => {
+      rl.close();
+      const idx = parseInt(answer, 10) - 1;
+      if (idx >= 0 && idx < options.length) {
+        resolve(options[idx]);
+      } else {
+        resolve(options[0]);
+      }
+    });
+  });
+}
+
+async function selectLanguage(flagLang) {
+  if (flagLang && ['en', 'pt-br'].includes(flagLang)) {
+    return flagLang;
+  }
+
+  const lang = await question('Select language / Selecione o idioma:', [
+    'en',
+    'pt-br',
+  ]);
+
+  return lang;
+}
+
+module.exports = { selectLanguage, question };

package/lib/utils.js

@@ -0,0 +1,69 @@
+const fs = require('fs');
+const path = require('path');
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function fileExists(filePath) {
+  return fs.existsSync(filePath);
+}
+
+function copyFile(src, dest, force = false) {
+  const exists = fileExists(dest);
+  if (exists && !force) {
+    return 'skipped';
+  }
+  ensureDir(path.dirname(dest));
+  fs.copyFileSync(src, dest);
+  return exists ? 'overwritten' : 'created';
+}
+
+function writeFile(filePath, content, force = false) {
+  const exists = fileExists(filePath);
+  if (exists && !force) {
+    return 'skipped';
+  }
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, content, 'utf-8');
+  return exists ? 'overwritten' : 'created';
+}
+
+function copyDir(srcDir, destDir, force = false) {
+  const results = { created: 0, skipped: 0, overwritten: 0 };
+
+  if (!fs.existsSync(srcDir)) {
+    return results;
+  }
+
+  const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(srcDir, entry.name);
+    const destPath = path.join(destDir, entry.name);
+
+    if (entry.isDirectory()) {
+      const sub = copyDir(srcPath, destPath, force);
+      results.created += sub.created;
+      results.skipped += sub.skipped;
+      results.overwritten += sub.overwritten;
+    } else {
+      const status = copyFile(srcPath, destPath, force);
+      results[status]++;
+    }
+  }
+
+  return results;
+}
+
+function log(status, filePath) {
+  const icons = {
+    created: '\x1b[32m+\x1b[0m',
+    skipped: '\x1b[33m~\x1b[0m',
+    overwritten: '\x1b[36m!\x1b[0m',
+  };
+  const icon = icons[status] || ' ';
+  const relative = path.relative(process.cwd(), filePath);
+  console.log(`  ${icon} ${relative} [${status}]`);
+}
+
+module.exports = { ensureDir, fileExists, copyFile, writeFile, copyDir, log };

package/lib/wrappers.js

@@ -0,0 +1,22 @@
+const path = require('path');
+const { PLATFORMS } = require('./constants');
+const { writeFile, log } = require('./utils');
+
+function generateWrappers(projectRoot, commands, force = false) {
+  const results = { created: 0, skipped: 0, overwritten: 0 };
+
+  for (const [platformName, platform] of Object.entries(PLATFORMS)) {
+    for (const cmd of commands) {
+      const skillDir = path.join(projectRoot, platform.dir, cmd.name);
+      const skillFile = path.join(skillDir, 'SKILL.md');
+      const content = platform.wrapperTemplate(cmd.name, cmd.description);
+      const status = writeFile(skillFile, content, force);
+      results[status]++;
+      log(status, skillFile);
+    }
+  }
+
+  return results;
+}
+
+module.exports = { generateWrappers };

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@brunosps00/dev-workflow",
+  "version": "0.0.3",
+  "description": "AI-driven development workflow commands for any project. Scaffolds a complete PRD-to-PR pipeline with multi-platform AI assistant support.",
+  "bin": {
+    "dev-workflow": "./bin/dev-workflow.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "scaffold/",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "ai",
+    "workflow",
+    "development",
+    "cli",
+    "claude",
+    "codex",
+    "copilot",
+    "opencode",
+    "prd",
+    "techspec",
+    "code-review",
+    "qa"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/brunosantos/dev-workflow"
+  },
+  "author": "Bruno Santos"
+}