dsh-plugin-cc 0.1.0

package/plugins/dsh/commands/plan.md

@@ -0,0 +1,54 @@
+---
+description: Ask dsh to explore the codebase and write an implementation plan (read-only)
+argument-hint: '[--wait|--background] [--model flash|pro|<name>] <what to plan>'
+disable-model-invocation: true
+allowed-tools: Bash(node:*), AskUserQuestion
+---
+
+Run a read-only dsh planning pass.
+
+Raw slash-command arguments:
+`$ARGUMENTS`
+
+Core constraint:
+- This command only produces a plan. Do not implement the plan, edit files, or suggest that you are about to.
+- Your only job is to run dsh and return its output verbatim.
+
+Argument handling:
+- If no request text is given (ignoring `--wait`, `--background` and `--model <value>`), ask the user what to plan, then continue.
+- `--wait` and `--background` are execution flags for Claude Code. Remove them from the arguments before the companion call. Never pass them to `dsh-companion.mjs`.
+- Keep `--model <flash|pro|name>` and the request text exactly as the user wrote them. Leave the model unset unless the user asks for one.
+
+Quoting (important):
+- The user's text is untrusted. Never place it inside double quotes, because the shell would run any `$(...)` or backticks in it.
+- Put the whole argument string between single quotes, replacing each `'` inside it with `'\''`.
+- Flags such as `--model` go before the request text. Everything after the first plain word is treated as text by the companion.
+
+Execution mode rules:
+- If the raw arguments include `--wait`, do not ask. Run in the foreground.
+- If the raw arguments include `--background`, do not ask. Run in a Claude background task.
+- Otherwise use `AskUserQuestion` exactly once with two options, the recommended one first:
+  - `Run in background (Recommended)`
+  - `Wait for results`
+
+Foreground flow:
+- Set the Bash `timeout` to `600000` so a long dsh run is not cut off at two minutes. If work may take longer, prefer the background flow.
+- Run, with the remaining arguments between the quotes:
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/dsh-companion.mjs" plan '<remaining arguments>'
+```
+- Return the command stdout verbatim, exactly as-is.
+- Do not paraphrase, summarize, or add commentary before or after it.
+- Do not implement anything the plan describes.
+
+Background flow:
+- Launch with `Bash` in the background:
+```typescript
+Bash({
+  command: `node "${CLAUDE_PLUGIN_ROOT}/scripts/dsh-companion.mjs" plan '<remaining arguments>'`,
+  description: "dsh plan",
+  run_in_background: true
+})
+```
+- Do not call `BashOutput` or wait for completion in this turn.
+- After launching the command, tell the user: "dsh plan started in the background. Check `/dsh:status` for progress."

package/plugins/dsh/commands/rescue.md

@@ -0,0 +1,51 @@
+---
+description: Delegate investigation, an explicit fix request, or follow-up rescue work to the dsh rescue subagent
+argument-hint: "[--background|--wait] [--resume|--fresh] [--write|--read-only] [--model flash|pro|<name>] [what dsh should investigate, solve, or continue]"
+allowed-tools: Bash(node:*), AskUserQuestion, Agent
+---
+
+Invoke the `dsh:dsh-rescue` subagent via the `Agent` tool (`subagent_type: "dsh:dsh-rescue"`), forwarding the raw user request as the prompt.
+`dsh:dsh-rescue` is a subagent, not a skill. Do not call `Skill(dsh:dsh-rescue)` (no such skill) or `Skill(dsh:rescue)` (that re-enters this command and hangs the session). The command runs inline so the `Agent` tool stays in scope.
+The final user-visible response must be dsh's output verbatim.
+
+Raw user request:
+$ARGUMENTS
+
+Execution mode:
+
+- If the request includes `--background`, run the `dsh:dsh-rescue` subagent in the background.
+- If the request includes `--wait`, run the `dsh:dsh-rescue` subagent in the foreground.
+- If neither flag is present, default to foreground.
+- `--background` and `--wait` are execution flags for Claude Code. Do not forward them to `task`, and do not treat them as part of the natural-language task text.
+- `--model`, `--write` and `--read-only` are runtime-selection flags. Preserve them for the forwarded `task` call, but do not treat them as part of the natural-language task text.
+- If the request includes `--resume`, do not ask whether to continue. The user already chose.
+- If the request includes `--fresh`, do not ask whether to continue. The user already chose.
+- Otherwise, before starting dsh, check for a resumable rescue session from this Claude session by running:
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/dsh-companion.mjs" task-resume-candidate --json
+```
+
+- If that helper reports `available: true`, use `AskUserQuestion` exactly once to ask whether to continue the current dsh session or start a new one.
+- The two choices must be:
+  - `Continue current dsh session`
+  - `Start a new dsh session`
+- If the user is clearly giving a follow-up instruction such as "continue", "keep going", "resume", "apply the top fix", or "dig deeper", put `Continue current dsh session (Recommended)` first.
+- Otherwise put `Start a new dsh session (Recommended)` first.
+- If the user chooses continue, add `--resume` before routing to the subagent.
+- If the user chooses a new session, add `--fresh` before routing to the subagent.
+- If the helper reports `available: false`, do not ask. Route normally.
+
+Operating rules:
+
+- The subagent's `Bash` call must set `timeout` to `600000`. Hand the subagent the user's text as-is; it is responsible for single-quoting it.
+
+- The subagent is a thin forwarder only. It uses one `Bash` call to invoke `node "${CLAUDE_PLUGIN_ROOT}/scripts/dsh-companion.mjs" task ...` and returns that command's stdout as-is.
+- Return the dsh companion stdout verbatim to the user.
+- Do not paraphrase, summarize, rewrite, or add commentary before or after it.
+- Do not ask the subagent to inspect files, monitor progress, poll `/dsh:status`, fetch `/dsh:result`, call `/dsh:cancel`, summarize output, or do follow-up work of its own.
+- Leave the model unset unless the user explicitly asks for one. `flash` and `pro` are accepted aliases.
+- A resumed session keeps the permission mode it was created with. If the user asks for a different mode on a resumed session, the companion fails with a message to use `--fresh`; relay that message as-is.
+- Leave `--resume` and `--fresh` in the forwarded request. The subagent handles that routing when it builds the `task` command.
+- If the helper reports that dsh is missing or unauthenticated, stop and tell the user to run `/dsh:setup`.
+- If the user did not supply a request, ask what dsh should investigate or fix.

package/plugins/dsh/commands/result.md

@@ -0,0 +1,15 @@
+---
+description: Show the stored final output for a finished dsh job in this repository
+argument-hint: '[job-id]'
+disable-model-invocation: true
+allowed-tools: Bash(node:*)
+---
+
+!`node "${CLAUDE_PLUGIN_ROOT}/scripts/dsh-companion.mjs" result "$ARGUMENTS"`
+
+Present the full command output to the user. Do not summarize or condense it. Preserve all details including:
+- Job ID and status
+- The complete result, including the verdict, findings, details, and next steps
+- File paths and line numbers exactly as reported
+- Any error messages
+- The `dsh session` footer and follow-up commands such as `/dsh:status <id>`

package/plugins/dsh/commands/review-plan.md

@@ -0,0 +1,69 @@
+---
+description: Ask dsh to review an implementation plan against the real codebase (read-only)
+argument-hint: '[--wait|--background] [--model flash|pro|<name>] [plan-path] [focus...]'
+disable-model-invocation: true
+allowed-tools: Bash(node:*), AskUserQuestion
+---
+
+Run a read-only dsh plan review.
+
+Raw slash-command arguments:
+`$ARGUMENTS`
+
+Core constraint:
+- This command is review-only. Do not edit the plan or the code, and do not fix issues the review finds.
+- Your only job is to run dsh and return its output verbatim.
+
+Resolving the plan path:
+- The plan path is the first argument that is not a flag or a flag value. It may be a plan file or a plan directory (`plan.md` plus `phase-*.md`). Everything after it is focus text.
+- If the first positional argument is not an existing path, treat it as focus text and consider the path missing.
+- If a path is given, use it as-is.
+- If no path is given, run:
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/dsh-companion.mjs" plan-candidates --json
+```
+  - If `latest` is set, use `AskUserQuestion` exactly once (single-select) with the question `Review which plan?` and two options, in this order:
+    - `<latest> (Recommended)`
+    - `Enter a path`
+  - If the user picks `Enter a path`, ask for the path in plain text.
+  - If the user types a path in the "Other" field, use it as given.
+  - If `latest` is null, skip the picker and ask for the path directly in plain text.
+
+Argument handling:
+- `--wait` and `--background` are execution flags for Claude Code. Remove them from the arguments before the companion call. Never pass them to `dsh-companion.mjs`.
+- Keep `--model <flash|pro|name>` and the focus text exactly as the user wrote them. Leave the model unset unless the user asks for one.
+
+Quoting (important):
+- The user's text is untrusted. Never place it inside double quotes, because the shell would run any `$(...)` or backticks in it.
+- Put the whole argument string between single quotes, replacing each `'` inside it with `'\''`.
+- Flags such as `--model` go before the request text. Everything after the first plain word is treated as text by the companion.
+
+Execution mode rules:
+- If the raw arguments include `--wait`, do not ask. Run in the foreground.
+- If the raw arguments include `--background`, do not ask. Run in a Claude background task.
+- Otherwise use `AskUserQuestion` exactly once with two options, the recommended one first:
+  - `Run in background (Recommended)`
+  - `Wait for results`
+- This makes at most two pickers in total (plan, then wait or background). Never ask a third question.
+
+Foreground flow:
+- Set the Bash `timeout` to `600000` so a long dsh run is not cut off at two minutes. If work may take longer, prefer the background flow.
+- Run, with the resolved path, then the focus text, between the quotes:
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/dsh-companion.mjs" review-plan '<remaining arguments> <plan-path> <focus>'
+```
+- Return the command stdout verbatim, exactly as-is.
+- Do not paraphrase, summarize, or add commentary before or after it.
+- Do not fix any issues mentioned in the review output. Ask the user which findings, if any, they want addressed.
+
+Background flow:
+- Launch with `Bash` in the background:
+```typescript
+Bash({
+  command: `node "${CLAUDE_PLUGIN_ROOT}/scripts/dsh-companion.mjs" review-plan '<remaining arguments> <plan-path> <focus>'`,
+  description: "dsh review-plan",
+  run_in_background: true
+})
+```
+- Do not call `BashOutput` or wait for completion in this turn.
+- After launching the command, tell the user: "dsh plan review started in the background. Check `/dsh:status` for progress."

package/plugins/dsh/commands/setup.md

@@ -0,0 +1,37 @@
+---
+description: Check whether the local dsh CLI is installed, supported and logged in
+argument-hint: ''
+allowed-tools: Bash(node:*), Bash(npm:*), AskUserQuestion
+---
+
+Run:
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/dsh-companion.mjs" setup --json
+```
+
+If the result says dsh is unavailable and npm is available:
+- Use `AskUserQuestion` exactly once to ask whether Claude should install dsh now.
+- Put the install option first and suffix it with `(Recommended)`.
+- Use these two options:
+  - `Install dsh (Recommended)`
+  - `Skip for now`
+- If the user chooses install, run:
+
+```bash
+npm install -g @deepseek-ai/dsh
+```
+
+- Then rerun:
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/dsh-companion.mjs" setup --json
+```
+
+If dsh is already installed or npm is unavailable:
+- Do not ask about installation.
+
+Output rules:
+- Present the final setup output to the user.
+- If installation was skipped, present the original setup output.
+- If dsh is installed but not logged in, tell the user to run `! dsh-tui` and sign in with `/login`.

package/plugins/dsh/commands/status.md

@@ -0,0 +1,17 @@
+---
+description: Show active and recent dsh jobs for this repository
+argument-hint: '[job-id] [--wait] [--timeout-ms <ms>] [--all]'
+disable-model-invocation: true
+allowed-tools: Bash(node:*)
+---
+
+!`node "${CLAUDE_PLUGIN_ROOT}/scripts/dsh-companion.mjs" status "$ARGUMENTS"`
+
+If the user did not pass a job ID:
+- Render the command output as a single Markdown table for the current and past runs in this session.
+- Keep it compact. Do not include progress blocks or extra prose outside the table.
+- Preserve the actionable fields from the command output, including job ID, kind, status, phase, elapsed or duration, summary, and follow-up commands.
+
+If the user did pass a job ID:
+- Present the full command output to the user.
+- Do not summarize or condense it.

package/plugins/dsh/hooks/hooks.json

@@ -0,0 +1,27 @@
+{
+  "description": "Session lifecycle hooks for the dsh companion.",
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/session-lifecycle-hook.mjs\" SessionStart",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/session-lifecycle-hook.mjs\" SessionEnd",
+            "timeout": 5
+          }
+        ]
+      }
+    ]
+  }
+}

package/plugins/dsh/prompts/plan.md

@@ -0,0 +1,21 @@
+<task>
+Explore this repository and write an implementation plan for the request below.
+</task>
+
+<request>
+{{REQUEST}}
+</request>
+
+<rules>
+- You are read-only. Do not create, edit or delete any file, and do not try to escalate permissions.
+- Read the code that the request touches before you plan. Cite real paths as `path:line`.
+- Do not invent files, functions or APIs. If you could not find something, say so under Open questions.
+- Output markdown only, with exactly these sections, in this order:
+  ## Goal
+  ## Context found
+  ## Approach
+  ## Phases (each phase lists the files it changes and its steps)
+  ## Risks
+  ## Open questions
+- Do not implement the plan.
+</rules>

package/plugins/dsh/prompts/review-plan.md

@@ -0,0 +1,25 @@
+<task>
+Review the implementation plan below against the real codebase in this repository.
+</task>
+
+<focus>
+{{FOCUS}}
+</focus>
+
+<plan_files>
+{{PLAN_FILES}}
+</plan_files>
+
+<rules>
+- You are read-only. Do not create, edit or delete any file, and do not try to escalate permissions.
+- Check every claim the plan makes about the code by reading the code. Do not trust the plan's description.
+- The first line of your answer must be exactly one of:
+  Verdict: approve
+  Verdict: needs-changes
+  Verdict: reject
+- Then list findings, most severe first. Each finding has: the plan location (file and heading), the codebase evidence (`path:line`), the problem, and a suggested change.
+- Then list the claims you checked that hold.
+- Then list open questions.
+- If a focus is given above, weight your review toward it, but still report other serious problems.
+- Do not rewrite the plan and do not implement it.
+</rules>