@bhargavvc/sdd-cc 1.42.3 → 1.42.4

package/commands/sdd/commit.md

@@ -0,0 +1,39 @@
+---
+name: sdd:commit
+description: Stage and commit current changes interactively with a conventional commit message.
+argument-hint: "[<commit message> | --all]"
+allowed-tools:
+  - Bash
+  - Read
+  - AskUserQuestion
+requires: [fast, quick]
+---
+
+<objective>
+Interactive git commit for the working tree. Surveys what is changed, suggests a conventional
+commit message based on the diff, asks the user to confirm, then stages the selected files and
+commits.
+
+This is the fork-added counterpart to the auto-commit step that was stripped from `/sdd:fast`.
+Use it after any task — `/sdd:fast`, `/sdd:quick`, manual edits, anything — when you are ready
+to checkpoint work without invoking a full phase workflow.
+
+**Never auto-stages with `git add -A` or `git add .` without explicit user consent** — those
+can sweep up `.env`, secrets, or build artifacts.
+</objective>
+
+<execution_context>
+@~/.claude/sdd/workflows/commit.md
+</execution_context>
+
+<process>
+Execute the workflow end-to-end.
+
+If the user passed a message as the first argument, use it verbatim and skip the message-suggestion
+step. If they passed `--all`, stage every tracked modification AND every untracked file (still
+asks for a final confirmation). Otherwise, run the full interactive flow.
+
+Set TEXT_MODE=true when `--text` is present in $ARGUMENTS or when `workflow.text_mode` is true.
+In TEXT_MODE every AskUserQuestion call is replaced with a plain-text numbered list and the user
+is asked to type their choice.
+</process>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bhargavvc/sdd-cc",
-  "version": "1.42.3",
+  "version": "1.42.4",
   "description": "A meta-prompting, context engineering and spec-driven development system for Claude Code, OpenCode, Gemini and Codex by TÂCHES.",
   "bin": {
     "sdd-cc": "bin/install.js",

package/sdd/bin/lib/clusters.cjs

@@ -97,6 +97,7 @@ const CLUSTERS = Object.freeze({
     'undo',
     'fast',
     'quick',
+    'commit',
     'autonomous',
     'config',
     'progress',

package/sdd/workflows/commit.md

@@ -0,0 +1,166 @@
+# /sdd:commit — Manual Conventional Commit
+
+Interactive git commit. Surveys the working tree, suggests a conventional commit message
+from the diff, asks the user to confirm, then stages + commits **specific files only**.
+
+This is the fork-added replacement for the auto-commit step previously embedded in `/sdd:fast`.
+Team policy: never auto-stage with `git add -A` / `git add .` without explicit consent.
+
+## Argument parsing
+
+Set TEXT_MODE=true if `--text` appears in `$ARGUMENTS` OR `workflow.text_mode` is true in the
+init JSON. When TEXT_MODE is active, replace every AskUserQuestion call below with a plain-text
+numbered list and ask the user to type their choice — every runtime can handle that, including
+non-Claude runtimes (Codex, Gemini) that render AskUserQuestion as inert markdown.
+
+## Process
+
+<step name="check_repo">
+Verify a git repository:
+
+```bash
+git rev-parse --show-toplevel
+```
+
+If this errors, STOP and tell the user: "Not in a git repository — nothing to commit."
+</step>
+
+<step name="survey_changes">
+Show the user what's changed:
+
+```bash
+echo "=== Tracked modifications ==="
+git status --short | grep -Ev "^\?\?" || echo "(none)"
+echo
+echo "=== Untracked files ==="
+git status --short | grep "^??" || echo "(none)"
+echo
+echo "=== Diff summary ==="
+git diff --stat HEAD 2>/dev/null
+```
+
+If working tree is clean (`git status --porcelain` empty), STOP and tell the user
+"Nothing to commit — working tree is clean."
+</step>
+
+<step name="select_files">
+Default behavior: **stage only tracked modifications** — never untracked, never `-A`.
+
+If untracked files exist, ask the user (via AskUserQuestion, or a plain-text numbered list
+when TEXT_MODE is active) which they want included:
+
+- **Tracked changes only** (recommended — safest)
+- **Also stage these untracked files: [list]** (only if user confirms each one is intentional)
+- **Cancel** — abort the commit
+
+If the user invoked the command with `--all`, skip the question but **still echo the file list
+back and ask one final yes/no confirmation** before proceeding — `--all` is not a license to
+commit secrets without showing the user.
+
+Refuse to stage files matching common secret patterns. If a candidate file matches any of these
+patterns, omit it from the stage list and warn the user:
+
+- `*.env`, `.env.*` (env files)
+- `*.pem`, `*.key`, `*.crt`, `*.p12`, `*.pfx` (keys / certs)
+- `*credentials*`, `*secret*`, `*token*` (credential-like names)
+- `node_modules/`, `dist/`, `build/`, `coverage/` (build artifacts — already gitignored, but defense-in-depth)
+
+The user can override per-file by re-running with the file explicitly named in their message.
+</step>
+
+<step name="suggest_message">
+If the user passed a message as the first argument, **use it verbatim** and skip to the next step.
+
+Otherwise, generate a conventional commit message from the staged diff:
+
+```bash
+git diff --cached    # primary source — only the files about to be committed
+```
+
+If nothing is staged yet (because we're previewing before staging), use:
+
+```bash
+git diff             # working-tree diff for the files we plan to stage
+```
+
+Pick a type from this table — choose the **dominant** change type, not the loudest:
+
+| Type       | When                                             |
+| ---------- | ------------------------------------------------ |
+| `feat`     | New user-facing feature, endpoint, component     |
+| `fix`      | Bug fix, error correction                        |
+| `refactor` | Internal cleanup, no behavior change             |
+| `test`     | Test-only changes (TDD RED, missing coverage)    |
+| `docs`     | Documentation only                               |
+| `chore`    | Config, tooling, deps, build scripts             |
+| `perf`     | Performance improvement, no behavior change      |
+| `style`    | Formatting, whitespace, no logic change          |
+
+Format: `<type>(<scope>): <subject>`
+- `<scope>` is optional — use it when changes are localized to one module (e.g., `feat(auth):`).
+- `<subject>` must be ≤ 72 chars, lowercase, no trailing period, imperative mood ("add X" not "added X").
+
+If the change is large enough to warrant a body, include 2-4 bullet lines beneath the subject
+explaining the *why* (not the *what* — the diff shows what).
+
+Show the user the proposed message + the staged file list. Ask (via AskUserQuestion, or a
+plain-text numbered list when TEXT_MODE is active):
+
+- **Commit with this message**
+- **Edit the message** — user types a replacement; you re-show + re-confirm
+- **Cancel** — abort, leave the working tree as-is
+</step>
+
+<step name="stage_and_commit">
+Stage the approved files explicitly — never `-A`, never `.`:
+
+```bash
+git add path/to/file1 path/to/file2 …
+```
+
+Commit using a HEREDOC for multi-line-message safety:
+
+```bash
+git commit -m "$(cat <<'EOF'
+<approved message>
+EOF
+)"
+```
+
+If a pre-commit hook fails:
+- Show the hook's output to the user
+- Do NOT pass `--no-verify` to bypass it
+- Stop and let the user fix the underlying issue, then re-run `/sdd:commit`
+
+Never `git commit --amend` an existing commit unless the user explicitly asked. Amend rewrites
+history and surprises co-authors.
+</step>
+
+<step name="report">
+Print the short hash and what landed:
+
+```
+✅ Committed {short-hash}: <type>(<scope>): <subject>
+   Files: <file1>, <file2>, …
+
+Run `git push` when ready (this skill does not push).
+```
+
+No next-step suggestions. No workflow routing. Done.
+</step>
+
+## Guardrails
+
+- NEVER `git add -A` or `git add .` without an explicit confirmation step that lists every file going in.
+- NEVER `git push` from this skill — pushing is a separate, riskier action; user runs it manually.
+- NEVER `--amend` unless the user explicitly asked.
+- NEVER pass `--no-verify` to bypass hooks — surface the failure and stop.
+- NEVER stage files matching the secret-pattern allowlist above without an explicit per-file confirmation.
+
+## Success criteria
+
+- [ ] User saw the proposed message before commit
+- [ ] User saw every file going into the commit
+- [ ] Commit landed on the current branch (not detached HEAD, not main without intent)
+- [ ] No `.env` / credentials / build artifacts were staged
+- [ ] No `--amend`, no `--no-verify`, no `git push`

package/sdd/workflows/fast.md

@@ -51,12 +51,13 @@ Do the work directly:
 **No PLAN.md.** Just do it.
 </step>
 
-<step name="commit">
-Commit the change atomically:
+<step name="halt_for_manual_commit">
+**FORK NOTE — this fork disables auto-commit.** Do NOT run `git add` or `git commit`. Stop here and tell the user:
 
-```bash
-git add -A
-git commit -m "fix: {concise description of what changed}"
+```
+✅ Changes applied. Review the diff and commit manually:
+   git add -A
+   git commit -m "fix: <concise description>"
 ```
 
 Use conventional commit format: `fix:`, `feat:`, `docs:`, `chore:`, `refactor:` as appropriate.
@@ -80,8 +81,8 @@ Report completion:
 
 ```
 ✅ Done: {what was changed}
-   Commit: {short hash}
    Files: {list of changed files}
+   Manual git: review diff and commit when ready (this fork does not auto-commit).
 ```
 
 No next-step suggestions. No workflow routing. Just done.
@@ -99,7 +100,7 @@ No next-step suggestions. No workflow routing. Just done.
 
 <success_criteria>
 - [ ] Task completed in current context (no subagents)
-- [ ] Atomic git commit with conventional message
+- [ ] Changes staged for user to commit manually (fork policy — no auto-commit)
 - [ ] STATE.md updated if it exists
 - [ ] Total operation under 2 minutes wall time
 </success_criteria>

package/sdd/workflows/help.md

@@ -191,6 +191,23 @@ For tasks too small to justify planning: typo fixes, config changes, forgotten c
 Usage: `/sdd:fast "fix the typo in README"`
 Usage: `/sdd:fast "add .env to gitignore"`
 
+---
+
+**`/sdd:commit [<message> | --all]`**
+Stage and commit current changes interactively with a conventional commit message.
+
+For when you have changes ready to checkpoint outside a phase workflow: review the diff, approve a suggested conventional message, commit specific files. Never `git add -A` without explicit user consent.
+
+- Surveys tracked vs untracked changes before staging
+- Suggests a conventional commit message from the diff (`feat`, `fix`, `refactor`, …)
+- Refuses common secret patterns (`.env`, `*.pem`, `*credentials*`) without per-file confirmation
+- Never `--amend`, never `--no-verify`, never `git push`
+- Replaces the auto-commit step previously embedded in `/sdd:fast`
+
+Usage: `/sdd:commit`
+Usage: `/sdd:commit "fix(auth): correct token refresh"`
+Usage: `/sdd:commit --all`
+
 ### Roadmap Management
 
 **`/sdd:phase <description>`**