rbin-task-flow 1.12.0 → 1.13.0

package/.cursor/rules/task_execution.mdc

@@ -22,6 +22,7 @@ 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: 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,74 @@
+---
+description: Run lint fix and build, then audit only uncommitted files against coding standards
+globs: **/*
+alwaysApply: true
+---
+
+# task-flow: improve changes
+
+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**.
+
+---
+
+## 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. **Lint and build** (see below): run lint fix if available; fix any lint warnings or errors; run build and fix if it fails.
+
+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.
+
+---
+
+## 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.
+
+---
+
+## 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
+
+> **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.**

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,9 @@ 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: 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 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,7 @@ 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: 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/bin/cli.js

@@ -6,6 +6,7 @@ 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 chalk = require('chalk');
 
 program
@@ -58,6 +59,15 @@ 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('info')
   .description('Show information about RBIN Task Flow')
@@ -74,6 +84,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 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/package.json

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