rbin-task-flow 1.19.5 → 1.23.0

package/.claude/skills/rbin-coding-standards/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: rbin-coding-standards
+description: Applies RBIN coding standards when implementing features. Use when the user invokes this skill, asks for coding standards, or is writing pages, components, services, use-cases, forms, or NestJS modules. Not auto-invoked — user or @mention required.
+disable-model-invocation: true
+paths: ["src/**", "app/**"]
+---
+
+# RBIN coding standards
+
+**Invoke only** (`/rbin-coding-standards` or `@rbin-coding-standards`). Do not load the full standards doc unless this skill runs or the user asks.
+
+## Steps
+
+1. Apply the **checklist** in `.cursor/rules/coding_standards.mdc` (default for all implementation). Do **not** read the entire `.mdc` or full markdown into context if the checklist already covers the task.
+2. Implement using checklist rules: `app/` thin, `features/`, `shared/`, service+use-case, RHF+zod+`Controller`, `cn()`, no `any`, no raw base UI.
+3. **Only if ambiguous** (Nest gateways, DataHandler, route groups, naming edge case): open **one or two sections** of `.task-flow/docs/coding-standards-full.md` — never paste or load the whole file.
+4. If `graphify-out/graph.json` exists, `graphify query` before choosing file paths for new code.
+5. No explanatory code comments; use `dev-logs/` for non-obvious design notes.
+
+## Token discipline
+
+| Do | Don't |
+|----|--------|
+| Checklist + targeted full-doc sections | Load all 800+ lines of full reference |
+| `@rbin-coding-standards` when coding | Rely on glob alone for complex architecture |
+
+## Quick reference
+
+[reference.md](reference.md) — checklist table + full-doc section index.

package/.claude/skills/rbin-coding-standards/reference.md

@@ -0,0 +1,42 @@
+# Coding standards — quick reference
+
+## Documents
+
+| Doc | Path | When |
+|-----|------|------|
+| **Checklist** (default) | `.cursor/rules/coding_standards.mdc` | Every implementation; glob on `src/**`, `app/**` in Cursor |
+| **Full reference** (sections only) | `.task-flow/docs/coding-standards-full.md` | Nest/Prisma detail, long examples, ESLint table, DataHandler, providers |
+
+## Checklist essentials
+
+| Area | Rule |
+|------|------|
+| Routes | `app/` only imports feature page/screen |
+| Pages | Orchestrators; short; compose components |
+| API | use-case (pure) + service (react-query) |
+| Forms | zod schema + `Controller` + `zodResolver` |
+| Classes | Always `cn()` |
+| Names | kebab-case + suffix (`.page.tsx`, `.use-case.ts`, …) |
+| Shared | Flat folders under `shared/`; no subfolders (web/mobile) |
+| Git | Never commit for user — `@rbin-git` suggests only |
+
+## Full doc — open by section (not whole file)
+
+| Section in `coding-standards-full.md` | Use when |
+|---------------------------------------|----------|
+| Project Structure | Unsure where a file belongs |
+| Tech Stack / ESLint | Stack or `@rbinflow/eslint-config` setup |
+| app/ — Routes Only | Next route groups, Nest controllers |
+| features/ — Feature Organization | Use-cases, repositories, page naming |
+| shared/ | Shared folder layout |
+| DataHandler | Loading/error UI pattern |
+| Feature `platform` | AppProviders, shell |
+| Providers Composition | Provider nesting |
+| cn() | Class merging edge cases |
+| React Query | Service + use-case examples |
+| Forms | InputText / Controller examples |
+| File Naming Conventions | Suffix disputes |
+| TypeScript Types | `.api.type.ts` vs `.type.ts` |
+| Context / Auth Hook | Auth provider pattern |
+| Testing | E2E placement |
+| Critical Rules | Final verification |

package/.claude/skills/rbin-git/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: rbin-git
+description: Suggests Conventional Commit messages after RBIN Task Flow work. Use after completing a subtask or task, when the user asks for a commit message, or when uncommitted changes exist. Never executes git add, commit, push, or other write git commands.
+disable-model-invocation: false
+---
+
+# RBIN — Git (suggest only)
+
+Complements `.cursor/rules/rbin-git-policy.mdc` (always-on).
+
+## Prohibited (never run)
+
+`git add`, `git commit`, `git push`, `git pull`, `git merge`, `git checkout`, `git reset`, `git rebase`, `git tag`, or any git command that modifies the repo.
+
+## Allowed (read-only)
+
+`git status`, `git diff`, `git log`, `git show`, `git branch` (list only).
+
+## After subtask/task done
+
+1. Run read-only: `git status --short`, `git diff --stat` (optional).
+2. Include Task/Subtask ID and title from Task Flow context.
+3. Use Conventional Commits: `feat`, `fix`, `refactor`, `docs`, `test`, `chore`.
+
+## Suggestion format
+
+```bash
+git add .
+git commit -m "feat(scope): Short description
+
+- Detail 1
+- Subtask ID: 3.2"
+```
+
+Present ready to copy. User runs git manually.
+
+## Reference
+
+Primary: `.cursor/rules/rbin-git-policy.mdc` · Extended: `git_control.mdc`, `commit_practices.mdc` (legacy)

package/.claude/skills/task-flow-audit/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: task-flow-audit
+description: Audits the full codebase against RBIN coding standards with a score table and asks which improvements to adopt. Use when the user says task-flow audit or audit coding standards for the whole project.
+disable-model-invocation: true
+---
+
+# Task Flow — Audit
+
+1. Scan project structure and `package.json`.
+2. Score categories vs `.cursor/rules/coding_standards.mdc` checklist (Full / Partial / Missing). Use `.task-flow/docs/coding-standards-full.md` only for deep dives — not the whole file.
+3. Present table and incremental improvement options.
+4. **Ask** user what to adopt; never impose refactors.
+5. Generate task lines for selected items only if user confirms.
+
+Non-destructive. Reference: `.cursor/rules/task_audit.mdc`

package/.claude/skills/task-flow-check/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: task-flow-check
+description: Runs project lint fix and build from package.json until passing. Use when the user says task-flow check, run lint and build, or validate project before commit.
+disable-model-invocation: true
+---
+
+# Task Flow — Check
+
+1. Read `package.json` scripts.
+2. Run lint with fix variant if present (`lint:fix`, `lint-fix`, or `lint -- --fix`); fix issues.
+3. Run `build` if defined; fix failures.
+4. Re-run until both pass.
+5. Report what ran and final status.
+
+Does not change task files. Reference: `.cursor/rules/task_check.mdc`

package/.claude/skills/task-flow-estimate/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: task-flow-estimate
+description: Estimates hours for RBIN Task Flow tasks for an average developer at average pace without AI acceleration. Use when the user says task-flow estimate X, estimate task 1, or time estimate for tasks.
+disable-model-invocation: true
+paths: [".task-flow/**"]
+---
+
+# Task Flow — Estimate
+
+1. Read `.task-flow/.internal/tasks.json` for task ID(s) or all.
+2. Infer complexity (low/medium/high) from title, description, subtasks, risk — not subtask count alone.
+3. Output single range in hours, e.g. `10-14 hours`.
+4. State assumption: average developer, average pace, no AI acceleration.
+
+Reference: `.cursor/rules/task_estimate.mdc`

package/.claude/skills/task-flow-generate-flow/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: task-flow-generate-flow
+description: Populates tasks.flow.md with dependencies, billing hours, and model recommendations for RBIN Task Flow tasks. Use when the user says task-flow generate flow, gerar flow, or tasks flow dependencies.
+disable-model-invocation: true
+paths: [".task-flow/**"]
+---
+
+# Task Flow — Generate flow
+
+1. Read `.task-flow/.internal/tasks.json` and optional `status.json`.
+2. For each task: dependencies, hour range (billing), 3 models (GPT-5.x, Composer, Claude Haiku/Sonnet only — **never Opus**).
+3. Write `.task-flow/tasks.flow.md` (overwrite populated sections).
+4. Use AI judgment for model order and effort per task.
+
+Reference: `.cursor/rules/task_generate_flow.mdc`

package/.claude/skills/task-flow-improve-changes/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: task-flow-improve-changes
+description: Audits only uncommitted files against coding standards. Use when the user says task-flow improve changes, audit my diff, or check uncommitted changes against standards.
+disable-model-invocation: true
+---
+
+# Task Flow — Improve changes
+
+1. Run `git diff --name-only HEAD` (read-only git).
+2. If empty, stop — no uncommitted changes.
+3. Audit **only** those paths using the same checklist as audit (`.cursor/rules/coding_standards.mdc`). Full reference: `.task-flow/docs/coding-standards-full.md` — relevant sections only if a category needs depth.
+4. Present findings; ask what to fix.
+5. Does **not** run lint/build — use `/task-flow-check` separately.
+
+Reference: `.cursor/rules/task_improve_changes.mdc`

package/.claude/skills/task-flow-refactor/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: task-flow-refactor
+description: Refactors code for task X without changing behavior; removes explanatory comments. Use when the user says task-flow refactor X or refactor completed task code.
+disable-model-invocation: true
+---
+
+# Task Flow — Refactor
+
+1. Identify files related to task X (from implementation scope).
+2. Remove explanatory comments; keep only `// ────────────────────────────────` section separators.
+3. Improve names/structure; **no** behavior change.
+4. Never run git write commands.
+
+Reference: `.cursor/rules/task_refactor.mdc`, `.cursor/rules/code_comments.mdc`

package/.claude/skills/task-flow-report/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: task-flow-report
+description: Generates implementation markdown report for completed RBIN Task Flow tasks. Use when the user says task-flow report X or document completed task.
+disable-model-invocation: true
+paths: [".task-flow/**"]
+---
+
+# Task Flow — Report
+
+1. Verify task X is fully `done` in `status.json` (warn if partial).
+2. Read `tasks.json`; analyze related code changes (read-only git ok).
+3. Write `.task-flow/docs/task-X-implementation.md` using project template.
+4. Create `.task-flow/docs/` if missing.
+
+Reference: `.cursor/rules/task_report.mdc`

package/.claude/skills/task-flow-review/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: task-flow-review
+description: Verifies completed RBIN Task Flow tasks are actually implemented in the codebase. Use when the user says task-flow review X, review task 1, or verify done tasks.
+disable-model-invocation: true
+---
+
+# Task Flow — Review
+
+1. Read `tasks.json`, `status.json` for task ID(s) X or `all`.
+2. For each subtask marked `done`: verify files/code/tests exist and match requirements.
+3. Report ✅ correct vs ⚠️ falsely marked done.
+4. Ask if user wants status reverted to `pending` / `in_progress`.
+
+Reference: `.cursor/rules/task_review.mdc`

package/.claude/skills/task-flow-run/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: task-flow-run
+description: Executes RBIN Task Flow subtasks from tasks.json and status.json. Use when the user says task-flow run, run next X subtasks, work on task N, execute pending subtasks, implement task flow, or trabalhar nas próximas subtarefas.
+disable-model-invocation: true
+paths: [".task-flow/**"]
+---
+
+# Task Flow — Run
+
+## Status
+
+!`head -40 .task-flow/tasks.status.md 2>/dev/null || echo "No tasks.status.md yet — run /task-flow-sync first"`
+
+## Steps
+
+1. Read `status.json` first; list **pending** task/subtask IDs only.
+2. **tasks.json (token discipline):** Count subtasks across all tasks. If **>50**, do **not** load the full file — read only the JSON slice for each active task id (pending subtasks you will run). If ≤50, full read is OK.
+3. Parse intent: `run next X` (default X=1) | `run X` | `run X,Y` | `run all`.
+4. **`run X` / `run X,Y`:** If any task before X has pending subtasks, **stop** and list blocking tasks.
+5. For each subtask: follow `instructions`; read `.task-flow/contexts/` files when referenced.
+6. If `graphify-out/graph.json` exists, prefer `graphify query "<module from subtask>"` before broad grep (summarized output only — see GRAPHIFY.md).
+7. After each subtask: update `status.json` and `tasks.status.md` (regenerate 📊 Summary).
+8. When parent task complete: mark task `done` in both files.
+9. Invoke `/rbin-git` logic to **suggest** commit only — never `git add`/`commit`/`push`.
+
+## Full workflow
+
+See [workflow.md](workflow.md).

package/.claude/skills/task-flow-run/workflow.md

@@ -0,0 +1,59 @@
+# task-flow-run — full workflow
+
+## Commands
+
+| Input | Behavior |
+|-------|----------|
+| `task-flow: run next X` | Next X pending subtasks in order (task 1.1, 1.2, …, 2.1, …) |
+| `task-flow: run next` | X = 1 |
+| `task-flow: run X` | All pending subtasks of task X |
+| `task-flow: run X,Y` | Tasks X then Y sequentially |
+| `task-flow: run all` | All pending subtasks |
+
+## Dependency check (`run X`)
+
+1. For tasks `1 .. X-1`, verify every subtask is `done`.
+2. If any pending: stop with  
+   `⚠️ Cannot execute task X: complete tasks [list] first. Use task-flow: run Y.`
+3. Do not execute any subtask of X until cleared.
+
+## tasks.json — partial read (>50 subtasks)
+
+1. From `status.json`, collect pending `(taskId, subtaskId)` for this run.
+2. Count total subtasks in `tasks.json` (quick parse or `jq '[.tasks[].subtasks | length] | add'`).
+3. If total **>50**: load **only** each `tasks[]` entry where `id` is in the pending set — not the full array.
+4. If **≤50**: loading the full `tasks.json` is acceptable.
+
+## Per subtask
+
+1. Load subtask from `tasks.json` (title, description, instructions) — slice for that task id only when using partial read.
+2. If instructions cite `.task-flow/contexts/...`, read those files.
+3. Implement; verify (tests/build as appropriate).
+4. Set subtask to `done` in `status.json`.
+5. Update `tasks.status.md`: `- [x]` on subtask; regenerate Summary (✅ / ⏳ / 📝 counts).
+6. If blocked: set `in_progress` and explain.
+
+## status.json shape
+
+```json
+{
+  "tasks": {
+    "1": {
+      "status": "pending",
+      "subtasks": { "1": "done", "2": "pending" }
+    }
+  }
+}
+```
+
+## Completion summary
+
+```
+✅ Completed N subtasks:
+- Task 1.2: [title]
+📝 Next pending: Task 1.3
+```
+
+## Related rules
+
+Cursor fallback (short): `.cursor/rules/task_work.mdc` — prefer `@task-flow-run` / this file.

package/.claude/skills/task-flow-status/SKILL.md

@@ -0,0 +1,13 @@
+---
+name: task-flow-status
+description: Shows RBIN Task Flow progress from tasks.status.md. Use when the user says task-flow status, show task status, status das tasks, or ver progresso das tarefas.
+disable-model-invocation: true
+---
+
+# Task Flow — Status
+
+1. Read `.task-flow/tasks.status.md`.
+2. Display summary (✅ completed, ⏳ in progress, 📝 remaining) and task/subtask checkboxes.
+3. If file missing, suggest `/task-flow-sync`.
+
+Reference: `.cursor/rules/task_status.mdc`

package/.claude/skills/task-flow-sync/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: task-flow-sync
+description: Synchronizes RBIN Task Flow tasks.input.txt with tasks.json, status.json, and tasks.status.md. Use when the user says task-flow sync, sync tasks, sincronizar tasks, or after editing tasks.input.txt.
+disable-model-invocation: true
+paths: [".task-flow/**"]
+---
+
+# Task Flow — Sync
+
+## Steps
+
+1. Read `.task-flow/tasks.input.txt` (only lines starting with `- `).
+2. Read `.task-flow/.internal/tasks.json` and `status.json` if they exist.
+3. Compare by `originalRequest`: new, removed, modified, unchanged tasks.
+4. **New:** generate subtasks (3–8 each), add pending status, update `tasks.status.md`. Subtask instructions: follow **checklist** in `.cursor/rules/coding_standards.mdc` only — not `.task-flow/docs/coding-standards-full.md`.
+5. **Removed:** delete from all three stores.
+6. **Modified:** update title/description, regenerate subtasks, **preserve** done/pending status where possible.
+7. **Unchanged:** leave task data and status as-is.
+8. Align `status.json` with `tasks.status.md` (`status.json` is source of truth).
+9. Regenerate 📊 Summary in `tasks.status.md`.
+10. Do **not** populate `tasks.flow.md` (only `task-flow: generate flow`).
+
+## Contexts
+
+- List `.task-flow/contexts/` and match files to tasks by keywords.
+- Honor `task-flow-screen filename.ext` → `.task-flow/contexts/filename.ext` in subtask instructions.
+
+## Full workflow
+
+See [workflow.md](workflow.md). Primary rule: `.cursor/rules/task-flow-sync.mdc` · Subtask templates: `.cursor/rules/task_generation.mdc`.

package/.claude/skills/task-flow-sync/workflow.md

@@ -0,0 +1,57 @@
+# task-flow-sync — full workflow
+
+**Primary rule:** `.cursor/rules/task-flow-sync.mdc` · Subtask templates: `task_generation.mdc`
+
+## New task generation
+
+For each new line in `tasks.input.txt`:
+
+- Assign sequential task id (order in file).
+- `originalRequest`: exact input line text.
+- `createdAt`: ISO 8601.
+- 3–8 subtasks with title, description, instructions (3–5 steps).
+- Reference contexts when relevant.
+
+## tasks.json (minimal)
+
+```json
+{
+  "tasks": [
+    {
+      "id": 1,
+      "title": "Task Title",
+      "description": "Task description",
+      "originalRequest": "- Task from input",
+      "createdAt": "2026-01-01T00:00:00.000Z",
+      "subtasks": [
+        {
+          "id": 1,
+          "title": "Subtask",
+          "description": "What it does",
+          "instructions": "Step 1: ...\nStep 2: ..."
+        }
+      ]
+    }
+  ]
+}
+```
+
+## status.json (new tasks)
+
+All subtasks `pending`; task `pending`.
+
+## tasks.status.md
+
+- Auto-generated banner warning (do not edit manually).
+- Summary section with counts.
+- `- [ ]` / `- [x]` for tasks and indented subtasks.
+
+## Sync-only rules
+
+- Preserve status on modified tasks when subtasks still match.
+- New subtasks after regen → `pending`; removed subtasks → drop from status.
+- Never explore codebase during pure sync unless user asked `think` in same message.
+
+## After sync
+
+Tell user: `task-flow: status` or `/task-flow-run run next X`.

package/.claude/skills/task-flow-think/SKILL.md

@@ -0,0 +1,17 @@
+---
+name: task-flow-think
+description: Analyzes the codebase and suggests new lines for tasks.input.txt without adding them automatically. Use when the user says task-flow think, suggest tasks, analise tasks novas, or check for missing tasks.
+disable-model-invocation: true
+---
+
+# Task Flow — Think
+
+1. Read `.task-flow/tasks.input.txt` (existing plan).
+2. Scan codebase: TODOs, missing tests, half-done features, security/perf gaps.
+3. Propose new tasks as `- Description` lines (RBIN format).
+4. **Ask** user before writing to `tasks.input.txt`.
+5. If user confirms, append only new lines; then suggest `/task-flow-sync`.
+
+Optional: `graphify query` on large repos before suggesting.
+
+Reference: `.cursor/rules/task_analysis.mdc` · Sync after confirm: `@task-flow-sync`

package/.codex/config.toml

@@ -0,0 +1,10 @@
+# RBIN Task Flow — optional Codex project config
+# Merged from repo root → cwd; see https://developers.openai.com/codex/config-advanced
+#
+# Installed by rbin-task-flow init. Edit as needed; preserved on update unless missing.
+
+# Default Codex cap is 32 KiB for combined AGENTS.md chain — raise if instructions truncate silently.
+project_doc_max_bytes = 65536
+
+# Optional: extra instruction filenames per directory (uncomment if needed)
+# project_doc_fallback_filenames = ["TEAM_AGENTS.md"]

package/.cursor/rules/code_comments.mdc

@@ -1,7 +1,7 @@
 ---
-description: Rules about code comments - prohibition of explanatory comments, use of dev-logs for documentation, and pattern for separation comments
-globs: **/*
-alwaysApply: true
+description: No explanatory code comments; use dev-logs. Applies when editing TypeScript or JavaScript source files.
+globs: **/*.{ts,tsx,js,jsx}
+alwaysApply: false
 ---
 
 - **Prohibition of Explanatory Comments:**
@@ -132,7 +132,7 @@ alwaysApply: true
 - **Integration with Other Rules:**
   - [cursor_rules.mdc](mdc:.cursor/rules/cursor_rules.mdc) - Rule formatting
   - [self_improve.mdc](mdc:.cursor/rules/self_improve.mdc) - Continuous improvement
-  - [commit_practices.mdc](mdc:.cursor/rules/commit_practices.mdc) - Commits can reference dev-logs
+  - [rbin-git-policy.mdc](mdc:.cursor/rules/rbin-git-policy.mdc) — commits can reference dev-logs in message body
 
 - **Fundamental Principle:**
   > **Code must be self-explanatory. If something needs explanation, document it in dev-logs/, not in code. Use comments only for visual organization following the exact pattern.**