rbin-task-flow 1.12.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,6 +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: 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

@@ -0,0 +1,51 @@
+---
+description: Audit only files changed in the current diff against coding standards
+globs: **/*
+alwaysApply: true
+---
+
+# task-flow: improve changes
+
+When the user runs `task-flow: improve changes`:
+
+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).
+
+---
+
+## Scope: uncommitted files only
+
+1. **Get the list of uncommitted files** (read-only git; do not run `git add`/`git commit`). Use the list of paths from:
+   - Modified but not staged: `git diff --name-only`
+   - Staged but not committed: `git diff --name-only --cached`
+   - Combined: all files that differ from `HEAD` → `git diff --name-only HEAD`
+   - **Use** `git diff --name-only HEAD` so that both unstaged and staged (but uncommitted) changes are included.
+
+2. If there are **no uncommitted changes**, tell the user and stop.
+
+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. **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**: 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.
+
+---
+
+## Natural language
+
+- **FAST FORMAT**: `task-flow: improve changes` or `task-flow improve changes`
+- "improve my changes", "audit my uncommitted changes", "check my changes against standards" → same command
+
+---
+
+## Principle
+
+> **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/.task-flow/README.md

@@ -15,6 +15,9 @@
 | `task-flow: refactor X` | Refactors specific task(s) (e.g., `task-flow: refactor 1` or `task-flow: refactor 10,11` or `task-flow: refactor all`) |
 | `task-flow: estimate X` | Estimates time for task X (e.g., `task-flow: estimate 1` or `task-flow: estimate 10,11`) |
 | `task-flow: report X` | Generates implementation report for task X (e.g., `task-flow: report 1` or `task-flow: report 10,11`) |
+| `task-flow: audit` | Audits codebase against coding standards and suggests incremental improvements |
+| `task-flow: improve changes` | Run lint fix + build (fix issues), then audit only uncommitted files |
+| `rbin-task-flow audit` | **(CLI)** Lists files with unstaged changes (not yet `git add`) |
 
 **See complete details below ↓**
 
@@ -36,6 +39,16 @@ Analyzes code and suggests new tasks. Asks before adding to `tasks.input.txt`.
 ### `task-flow: status`
 Shows current status of tasks and subtasks from the `tasks.status.md` file.
 
+### `task-flow: audit`
+Audits the **entire codebase** against the coding standards in [coding_standards.mdc](.cursor/rules/coding_standards.mdc). Non-destructive: reports gaps and suggests incremental improvements; the user chooses what to adopt. See [task_audit.mdc](.cursor/rules/task_audit.mdc) for the full flow.
+
+### `task-flow: improve changes`
+1. **Lint and build**: Run lint fix if the project has it; fix any lint warnings or errors; run build and fix until it passes.  
+2. **Audit uncommitted only**: Same as **task-flow: audit**, but **only for files that were changed and not yet committed** (unstaged + staged). Use before committing to align the current change set with coding standards. The AI obtains the list of uncommitted files and runs the audit flow restricted to those paths.
+
+### `rbin-task-flow audit` (CLI only)
+Lists **unstaged** file paths (modified but not yet `git add`). Run in the project root: `rbin-task-flow audit`. Option: `-p, --path <path>`.
+
 ---
 
 ## Commands with Task ID

package/AGENTS.md

@@ -29,8 +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: 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: 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,6 +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: 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

@@ -6,6 +6,8 @@ const { installInProject } = require('../lib/install');
 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
@@ -58,6 +60,24 @@ program
     await generateReport(taskIds, targetPath);
   });
 
+program
+  .command('audit')
+  .description('List files with unstaged changes (not yet git add)')
+  .option('-p, --path <path>', 'Target directory (default: current directory)')
+  .action(async (options) => {
+    const targetPath = options.path || process.cwd();
+    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')
@@ -74,6 +94,8 @@ 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/audit.js

@@ -0,0 +1,44 @@
+const { execSync } = require('child_process');
+const path = require('path');
+const chalk = require('chalk');
+
+function getUnstagedFiles(targetPath) {
+  const cwd = path.resolve(targetPath);
+  try {
+    const out = execSync('git diff --name-only', { encoding: 'utf8', cwd });
+    return out
+      .trim()
+      .split('\n')
+      .filter(Boolean);
+  } catch (err) {
+    if (err.stderr && (err.stderr.includes('not a git repository') || err.message.includes('not a git'))) {
+      return null;
+    }
+    throw err;
+  }
+}
+
+async function runAudit(targetPath = process.cwd()) {
+  const files = getUnstagedFiles(targetPath);
+
+  if (files === null) {
+    console.log(chalk.red('❌ Not a git repository. Run from a project root with git initialized.'));
+    return;
+  }
+
+  if (files.length === 0) {
+    console.log(chalk.yellow('⚠️  No unstaged changes. All modified files are staged (or working tree is clean).'));
+    console.log(chalk.gray('   Use "task-flow: audit" after editing files and before "git add".'));
+    return;
+  }
+
+  console.log(chalk.cyan('📋 Unstaged files (not yet added with git add):'));
+  console.log(chalk.cyan('─'.repeat(50)));
+  files.forEach((f) => console.log(chalk.white('  ' + f)));
+  console.log(chalk.cyan('─'.repeat(50)));
+  console.log(chalk.magenta('  Total:'), chalk.yellow(files.length), chalk.magenta('file(s)'));
+  console.log('');
+  console.log(chalk.gray('  Tip: run lint/test only on these paths, then "git add" when ready.'));
+}
+
+module.exports = { runAudit, getUnstagedFiles };

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.12.0",
+  "version": "1.14.0",
   "description": "AI-powered task management for Claude and Cursor",
   "main": "index.js",
   "bin": {