rbin-task-flow 1.13.0 → 1.14.0

package/.cursor/rules/task_check.mdc

@@ -0,0 +1,38 @@
+---
+description: Run lint fix when available, then build the current project
+globs: **/*
+alwaysApply: true
+---
+
+# task-flow: check
+
+When the user runs `task-flow: check`:
+
+1. **Detect project scripts**: Read `package.json` and look for lint and build scripts.
+2. **Run lint first**: Prefer a fix-capable lint command if present (`lint:fix`, `lint-fix`, or equivalent). If there is only `lint`, run it and fix the reported issues.
+3. **Run build next**: If a `build` script exists, run it after lint succeeds.
+4. **Fix failures**: If lint or build fails, fix the issues and re-run until they pass.
+5. **Keep scope local**: This command is only for project checks. It does not run the coding-standards audit and does not change task files by itself.
+
+---
+
+## How to execute
+
+- **Step 1**: Read `package.json` and identify which package manager and scripts the project uses.
+- **Step 2**: Run lint first, preferring an autofix variant when one exists.
+- **Step 3**: Fix any lint errors or warnings that should be resolved now.
+- **Step 4**: Run build and fix any failures.
+- **Step 5**: Report what ran, what was skipped, and whether the project is passing.
+
+---
+
+## Natural language
+
+- **FAST FORMAT**: `task-flow: check` or `task-flow check`
+- "run checks", "run lint and build", "validate this project" → same command
+
+---
+
+## Principle
+
+> **Use `task-flow: check` to make the current project pass its local validation steps before reviewing or committing changes.**

package/.cursor/rules/task_execution.mdc

@@ -22,7 +22,8 @@ alwaysApply: true
   - `task-flow: sync` - Sync new tasks from tasks.input.txt
   - `task-flow: think` - Analyze codebase and suggest new tasks
   - `task-flow: audit` - Audit codebase against coding standards and suggest incremental improvements
-  - `task-flow: improve changes` - Run lint fix and build (fix issues), then audit only uncommitted files
+  - `task-flow: check` - Run lint fix when available, then build the current project
+  - `task-flow: improve changes` - Audit only files changed in the current diff against `HEAD`
   - `task-flow: run next X` - Work on next X subtasks sequentially
   - `task-flow: run X` - Work on all pending subtasks of task X (simplified - no "task" needed)
   - `task-flow: run X,Y` - Work on multiple tasks (comma-separated)

package/.cursor/rules/task_improve_changes.mdc

@@ -1,5 +1,5 @@
 ---
-description: Run lint fix and build, then audit only uncommitted files against coding standards
+description: Audit only files changed in the current diff against coding standards
 globs: **/*
 alwaysApply: true
 ---
@@ -8,8 +8,8 @@ alwaysApply: true
 
 When the user runs `task-flow: improve changes`:
 
-1. **Lint and build**: Check if the project has a lint-fix script and a build script; run lint fix, fix any warnings or errors, then run build and fix until it passes.
-2. **Audit uncommitted only**: Then do the **same as** [task-flow: audit](mdc:.cursor/rules/task_audit.mdc) (codebase audit against [coding_standards.mdc](mdc:.cursor/rules/coding_standards.mdc)), but **restricted to files that were changed and not yet committed**.
+1. **Audit current changes only**: Do the **same as** [task-flow: audit](mdc:.cursor/rules/task_audit.mdc) (codebase audit against [coding_standards.mdc](mdc:.cursor/rules/coding_standards.mdc)), but **restricted to files that were changed and not yet committed**.
+2. **Do not run project checks here**: Lint fix and build now belong to [task-flow: check](mdc:.cursor/rules/task_check.mdc).
 
 ---
 
@@ -23,42 +23,19 @@ When the user runs `task-flow: improve changes`:
 
 2. If there are **no uncommitted changes**, tell the user and stop.
 
-3. **Lint and build** (see below): run lint fix if available; fix any lint warnings or errors; run build and fix if it fails.
+3. **Restrict the audit to those paths**: when performing the steps from [task_audit.mdc](mdc:.cursor/rules/task_audit.mdc) (explore, score, report, ask what to adopt, generate tasks), consider **only** the files in the list above. Do not score or suggest improvements for files that were not changed.
 
-4. **Restrict the audit to those paths**: when performing the steps from [task_audit.mdc](mdc:.cursor/rules/task_audit.mdc) (explore, score, report, ask what to adopt, generate tasks), consider **only** the files in the list above. Do not score or suggest improvements for files that were not changed.
-
-5. **Same principles as audit**: non-destructive, incremental, suggest improvements and let the user choose. Only the scope is different: uncommitted files only.
-
----
-
-## Lint fix and build (mandatory before audit)
-
-Before running the coding-standards audit on uncommitted files:
-
-1. **Check for lint fix**: Read `package.json` and look for scripts that run lint with fix (e.g. `lint:fix`, `lint --fix`, `lint-fix`, or `lint` with a fix option). Common names: `lint:fix`, `lint -- --fix`, `eslint . --fix`, `npm run lint -- --fix`.
-
-2. **Run lint fix**: If such a script exists, run it (e.g. `npm run lint:fix` or `pnpm run lint -- --fix`). You may run npm/pnpm/yarn without asking per project rules.
-
-3. **Fix lint output**: If lint reports **warnings or errors** after the fix run, correct them in the code (only in the affected files when possible). Re-run lint until there are no errors; reduce warnings where feasible.
-
-4. **Check for build**: Look for a `build` (or `build:prod`, `build:dev`) script in `package.json`.
-
-5. **Run build**: If a build script exists, run it (e.g. `npm run build`). If the **build fails**, fix the failing errors (compile errors, type errors, missing deps) and re-run until the build passes.
-
-6. **Order**: Run lint fix (and fix issues) first, then build (and fix issues). Only after both are passing, proceed with the coding-standards audit on uncommitted files.
-
-If the project has no lint fix script or no build script, skip the missing step and continue with the audit.
+4. **Same principles as audit**: non-destructive, incremental, suggest improvements and let the user choose. Only the scope is different: uncommitted files only.
 
 ---
 
 ## How to execute
 
 - **Step 1**: Obtain uncommitted file list (e.g. run `git diff --name-only HEAD` or use your tools to get the list). If empty, stop.
-- **Step 2**: **Lint and build**: run lint fix if available; fix any lint warnings/errors; run build and fix until it passes (see "Lint fix and build" above).
-- **Step 3**: Read and analyze **only** the uncommitted files (and their immediate context if needed).
-- **Step 4**: For that subset, apply the same categories and scoring as in task-flow: audit (folder structure, thin app/, naming, cn(), forms, etc.) and note which of those categories are relevant to the changed files.
-- **Step 5**: Present findings and suggested improvements **only for the uncommitted files**.
-- **Step 6**: Ask which improvements the user wants; generate tasks or concrete edits only for the selected items, touching only uncommitted files where possible.
+- **Step 2**: Read and analyze **only** the uncommitted files (and their immediate context if needed).
+- **Step 3**: For that subset, apply the same categories and scoring as in task-flow: audit (folder structure, thin app/, naming, cn(), forms, etc.) and note which of those categories are relevant to the changed files.
+- **Step 4**: Present findings and suggested improvements **only for the uncommitted files**.
+- **Step 5**: Ask which improvements the user wants; generate tasks or concrete edits only for the selected items, touching only uncommitted files where possible.
 
 ---
 
@@ -71,4 +48,4 @@ If the project has no lint fix script or no build script, skip the missing step
 
 ## Principle
 
-> **Same as audit, but scoped to what the developer is about to commit. First ensure lint fix runs and build passes (fixing any warnings/errors); then run the coding-standards audit on uncommitted files. Use it to tighten quality and standards on the current change set before committing.**
+> **Use `task-flow: improve changes` as a scoped audit for the current diff against `HEAD`. Use `task-flow: check` separately when you want lint/build validation.**

package/AGENTS.md

@@ -29,9 +29,10 @@ This repo follows the same development norms as in `.cursor/rules/` and `CLAUDE.
 - **Task flow** always means **RBIN Task Flow**.
 - Tasks: `.task-flow/tasks.input.txt` (format: `- Task description`).
 - Status: `.task-flow/tasks.status.md` and `.task-flow/.internal/status.json`.
-- **Commands** to support: `task-flow: sync`, `task-flow: think`, `task-flow: audit`, `task-flow: improve changes`, `task-flow: status`, `task-flow: run next X`, `task-flow: run X` (or `X,Y` / `all`), `task-flow: review X`, `task-flow: refactor X`, `task-flow: estimate X`, `task-flow: report X`.
+- **Commands** to support: `task-flow: sync`, `task-flow: think`, `task-flow: audit`, `task-flow: check`, `task-flow: improve changes`, `task-flow: status`, `task-flow: run next X`, `task-flow: run X` (or `X,Y` / `all`), `task-flow: review X`, `task-flow: refactor X`, `task-flow: estimate X`, `task-flow: report X`.
 - When running `task-flow: audit`: scan the codebase, score it against `.cursor/rules/coding_standards.mdc`, present a report, and ask the user which improvements to adopt — never impose changes.
-- When running `task-flow: improve changes`: (1) run lint fix if present and fix lint warnings/errors; run build and fix until it passes; (2) then same as audit but only for files changed and not yet committed (obtain list via `git diff --name-only HEAD`, then audit only those paths).
+- When running `task-flow: check`: run lint fix if present and fix lint warnings/errors; run build and fix until it passes.
+- When running `task-flow: improve changes`: same as audit but only for files changed and not yet committed (obtain list via `git diff --name-only HEAD`, then audit only those paths).
 - When running subtasks: read `.task-flow/.internal/tasks.json` and `status.json`, implement, then update `status.json` and `tasks.status.md` (mark done, refresh summary).
 - Use context from `.task-flow/contexts/` when subtask instructions reference it.
 

package/CLAUDE.md

@@ -22,7 +22,8 @@ This project uses RBIN Task Flow for task management:
   - `task-flow: sync` - Synchronize tasks from tasks.input.txt
   - `task-flow: think` - Analyze code and suggest new tasks
   - `task-flow: audit` - Audit codebase against coding standards and suggest incremental improvements
-  - `task-flow: improve changes` - Run lint fix and build (fix issues), then audit only uncommitted files
+  - `task-flow: check` - Run lint fix when available, then build the current project
+  - `task-flow: improve changes` - Audit only files changed in the current diff against `HEAD`
   - `task-flow: status` - View current task status
   - `task-flow: run next X` - Work on next X subtasks
   - `task-flow: run X` - Execute all pending subtasks of task X (simplified - no "task" needed)

package/README.md

@@ -73,6 +73,7 @@ rbin-task-flow init          # Inicializa no projeto atual
 rbin-task-flow update        # Atualiza configurações
 rbin-task-flow version-check # Verifica atualizações de modelos
 rbin-task-flow info          # Mostra informações
+rbin-task-flow check         # Roda lint/fix e build quando existirem
 rbin-task-flow estimate <ids> # Estima tempo (ex: "1" ou "1,2" ou "all")
 rbin-task-flow report <ids>  # Gera relatório (ex: "1" ou "1,2" ou "all")
 ```
@@ -86,6 +87,8 @@ Após inicializar, use estes comandos na IA (Cursor/Claude) para gerenciar taref
 | `task-flow: sync` | **Sincroniza** tarefas do arquivo texto com o sistema | Mantém tudo sincronizado automaticamente - adiciona novas, remove deletadas, preserva seu progresso |
 | `task-flow: think` | **Descobre** tarefas que você esqueceu | Analisa código e sugere tarefas que faltam (testes, refatoração, documentação) |
 | `task-flow: audit` | **Avalia** o quanto o código bate com os padrões de codificação | Analisa a codebase, dá um score por categoria e pergunta quais melhorias você quer adotar — sem impor nada |
+| `task-flow: check` | **Valida** lint e build antes de revisar ou commitar | Roda lint com fix quando disponível e depois build, corrigindo problemas do projeto atual |
+| `task-flow: improve changes` | **Audita** só o diff atual | Faz o mesmo audit de padrões, mas restrito aos arquivos alterados em relação ao `HEAD` |
 | `task-flow: status` | **Visualiza** o progresso rapidamente | Vê resumo com tasks completas, em andamento e quantas subtarefas faltam |
 | `task-flow: run next X` | **Automatiza** o trabalho nas próximas subtarefas | A IA trabalha nas próximas X subtarefas sequencialmente, você só acompanha |
 | `task-flow: run X` | **Completa** uma tarefa inteira de uma vez | Executa todas as subtarefas de uma tarefa específica (permite trabalho paralelo) |
@@ -417,6 +420,7 @@ rbin-task-flow init          # Initialize in current project
 rbin-task-flow update        # Update configurations
 rbin-task-flow version-check # Check for model updates
 rbin-task-flow info          # Show information
+rbin-task-flow check         # Run lint/fix and build when available
 rbin-task-flow estimate <ids> # Estimate time (e.g., "1" or "1,2" or "all")
 rbin-task-flow report <ids>   # Generate report (e.g., "1" or "1,2" or "all")
 ```
@@ -430,6 +434,8 @@ After initializing, use these commands in your AI (Cursor/Claude) to automatical
 | `task-flow: sync` | **Sync** tasks from text file with system | Keeps everything synchronized automatically - adds new, removes deleted, preserves your progress |
 | `task-flow: think` | **Discover** tasks you forgot | Analyzes code and suggests missing tasks (tests, refactoring, documentation) |
 | `task-flow: audit` | **Evaluate** how well your code matches coding standards | Scans the codebase, scores it by category and asks which improvements you want to adopt — never imposes changes |
+| `task-flow: check` | **Validate** lint and build before review or commit | Runs lint with autofix when available and then build, fixing current-project issues first |
+| `task-flow: improve changes` | **Audit** only the current diff | Runs the same standards audit, but restricted to files changed relative to `HEAD` |
 | `task-flow: status` | **Visualize** progress quickly | See summary with completed tasks, in progress, and remaining subtasks |
 | `task-flow: run next X` | **Automate** work on next subtasks | AI works on next X subtasks sequentially, you just follow along |
 | `task-flow: run X` | **Complete** an entire task at once | Executes all subtasks of a specific task (allows parallel work) |

package/bin/cli.js

@@ -7,6 +7,7 @@ const { checkVersionUpdates } = require('../lib/version');
 const { estimateTask } = require('../lib/estimate');
 const { generateReport } = require('../lib/report');
 const { runAudit } = require('../lib/audit');
+const { runCheck } = require('../lib/check');
 const chalk = require('chalk');
 
 program
@@ -68,6 +69,15 @@ program
     await runAudit(targetPath);
   });
 
+program
+  .command('check')
+  .description('Run lint fix when available, then build')
+  .option('-p, --path <path>', 'Target directory (default: current directory)')
+  .action(async (options) => {
+    const targetPath = options.path || process.cwd();
+    await runCheck(targetPath);
+  });
+
 program
   .command('info')
   .description('Show information about RBIN Task Flow')
@@ -84,6 +94,7 @@ program
     console.log(chalk.cyan('  rbin-task-flow version-check') + ' - Check for model updates');
     console.log(chalk.cyan('  rbin-task-flow estimate <ids>') + ' - Estimate time (e.g., "1" or "1,2" or "all")');
     console.log(chalk.cyan('  rbin-task-flow report <ids>') + '  - Generate report (e.g., "1" or "1,2" or "all")');
+    console.log(chalk.cyan('  rbin-task-flow check') + '       - Run lint fix and build when available');
     console.log(chalk.cyan('  rbin-task-flow audit') + '       - List unstaged files (not yet git add)');
     console.log(chalk.cyan('  rbin-task-flow info') + '         - Show this information\n');
   });

package/lib/check.js

@@ -0,0 +1,113 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const chalk = require('chalk');
+
+function getPackageManager(targetPath) {
+  const cwd = path.resolve(targetPath);
+
+  if (fs.existsSync(path.join(cwd, 'pnpm-lock.yaml'))) {
+    return 'pnpm';
+  }
+
+  if (fs.existsSync(path.join(cwd, 'yarn.lock'))) {
+    return 'yarn';
+  }
+
+  if (fs.existsSync(path.join(cwd, 'bun.lockb')) || fs.existsSync(path.join(cwd, 'bun.lock'))) {
+    return 'bun';
+  }
+
+  return 'npm';
+}
+
+function readPackageJson(targetPath) {
+  const packageJsonPath = path.join(path.resolve(targetPath), 'package.json');
+
+  if (!fs.existsSync(packageJsonPath)) {
+    return null;
+  }
+
+  return JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+}
+
+function buildRunCommand(packageManager, scriptName, args = []) {
+  if (packageManager === 'yarn') {
+    return ['yarn', scriptName, ...args].join(' ');
+  }
+
+  return [packageManager, 'run', scriptName, ...(args.length > 0 ? ['--', ...args] : [])].join(' ');
+}
+
+function resolveLintScript(scripts = {}) {
+  if (scripts['lint:fix']) {
+    return { scriptName: 'lint:fix', label: 'lint:fix' };
+  }
+
+  if (scripts['lint-fix']) {
+    return { scriptName: 'lint-fix', label: 'lint-fix' };
+  }
+
+  if (scripts.lint) {
+    if (scripts.lint.includes('--fix')) {
+      return { scriptName: 'lint', label: 'lint' };
+    }
+
+    return { scriptName: 'lint', args: ['--fix'], label: 'lint --fix' };
+  }
+
+  return null;
+}
+
+function runScript(targetPath, packageManager, scriptConfig) {
+  const command = buildRunCommand(packageManager, scriptConfig.scriptName, scriptConfig.args);
+  execSync(command, {
+    cwd: path.resolve(targetPath),
+    stdio: 'inherit',
+    encoding: 'utf8'
+  });
+}
+
+async function runCheck(targetPath = process.cwd()) {
+  const cwd = path.resolve(targetPath);
+  const packageJson = readPackageJson(cwd);
+
+  if (!packageJson) {
+    console.log(chalk.red('❌ package.json not found. Run this command from a project root.'));
+    return;
+  }
+
+  const packageManager = getPackageManager(cwd);
+  const scripts = packageJson.scripts || {};
+  const lintScript = resolveLintScript(scripts);
+  const hasBuild = Boolean(scripts.build);
+  let ranSomething = false;
+
+  console.log(chalk.cyan('🔎 Running project checks'));
+  console.log(chalk.gray(`   Package manager: ${packageManager}`));
+
+  if (lintScript) {
+    ranSomething = true;
+    console.log(chalk.cyan(`\n▶ Running ${lintScript.label}`));
+    runScript(cwd, packageManager, lintScript);
+  } else {
+    console.log(chalk.yellow('\n⚠️  No lint script found. Skipping lint step.'));
+  }
+
+  if (hasBuild) {
+    ranSomething = true;
+    console.log(chalk.cyan('\n▶ Running build'));
+    runScript(cwd, packageManager, { scriptName: 'build' });
+  } else {
+    console.log(chalk.yellow('\n⚠️  No build script found. Skipping build step.'));
+  }
+
+  if (!ranSomething) {
+    console.log(chalk.yellow('\n⚠️  Nothing to run. Add a lint and/or build script to package.json.'));
+    return;
+  }
+
+  console.log(chalk.green('\n✅ Checks completed successfully.'));
+}
+
+module.exports = { runCheck };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rbin-task-flow",
-  "version": "1.13.0",
+  "version": "1.14.0",
   "description": "AI-powered task management for Claude and Cursor",
   "main": "index.js",
   "bin": {