feat(engines): add qwen (Qwen Code) and deepseek (DeepSeek Code)

`/install qwen` and `/install deepseek` now resolve, alongside the kimi
entry added in #286.

qwen is a Gemini CLI fork, so it reuses gemini's `--approval-mode=yolo`
for agent mode — `--yolo`/`-y` names the same mode, and passing both is a
hard error, so only one form is wired.

deepseek has no first-party CLI; `@serjm/deepseek-code` is the live
community one. The two names that get suggested alongside it are dead
ends: `deepseek-tui` is now a stub whose own description says it was
renamed to `codewhale`, and `deepseek-cli` has not shipped since January
2025. Its package installs `dsc` and `deepseek-code`; we launch the long
name, because `dsc` collides with Microsoft's Desired State
Configuration binary and the short name would silently start the wrong
program on a machine that has both.

The agents/start test loop now writes its stub under the engine's *bin*
rather than its key. Those were the same string for every engine until
now; deepseek is the first where they differ, and a stub named after the
key would leave nothing on PATH to find.

MCP and skills fan-out stay opt-in per engine, so both new engines report
"no support" there until their native `mcp add` surfaces are wired.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: ralyodio

README.md

@@ -62,6 +62,8 @@ moshcode install privacycode # curl -fsSL https://getprivacycode.com/install | s
 moshcode install claude     # npm i -g @anthropic-ai/claude-code
 moshcode install codex      # npm i -g @openai/codex
 moshcode install kimi       # curl -fsSL https://code.kimi.com/kimi-code/install.sh | bash
+moshcode install qwen       # npm i -g @qwen-code/qwen-code
+moshcode install deepseek   # npm i -g @serjm/deepseek-code
 ```
 
 ### Autonomous agents versus raw starts
@@ -78,6 +80,8 @@ moshcode agents privacycode # privacycode agent list                       (agen
 moshcode agents codex       # codex --dangerously-bypass-approvals-and-sandbox  (autonomous)
 moshcode agents gemini      # gemini --approval-mode=yolo                       (autonomous)
 moshcode agents kimi        # kimi --yolo                                       (autonomous)
+moshcode agents qwen        # qwen --approval-mode=yolo                         (autonomous)
+moshcode agents deepseek    # deepseek-code --turbo                             (autonomous)
 moshcode agents aider       # aider --yes-always                                (autonomous)
 ```
 

src/engines.mjs

@@ -95,6 +95,34 @@ export const ENGINES = {
     // lands in the rc the same way; only the default needs bridging here.)
     binDirs: [path.join(homedir(), ".kimi-code", "bin")],
   },
+  qwen: {
+    desc: "Qwen Code — Alibaba's agentic coding CLI",
+    bin: "qwen",
+    // A Gemini CLI fork, so it takes gemini's approval-mode flag. `--yolo`/`-y`
+    // selects the same mode by another name, and passing both is a hard error
+    // ("Cannot use --yolo (-y) and --approval-mode together"), so this stays on
+    // the one form — the gemini-shaped one, matching the entry above.
+    agentArgs: ["--approval-mode=yolo"],
+    install: { cmd: "npm", args: ["install", "-g", "@qwen-code/qwen-code"] },
+  },
+  deepseek: {
+    desc: "DeepSeek Code — terminal coding agent on DeepSeek models",
+    // Community-built (SerjMihashin), not a DeepSeek-published CLI — DeepSeek
+    // ships no first-party agentic CLI. The two other names that get suggested
+    // are dead ends: `deepseek-tui` is now a stub whose own description says it
+    // was renamed to `codewhale`, and `deepseek-cli` has not been touched since
+    // January 2025.
+    //
+    // The package installs two identical bins, `dsc` and `deepseek-code`. Take
+    // the long one: `dsc` is also Microsoft's Desired State Configuration
+    // binary, so on a machine that has both, the short name would silently
+    // launch the wrong program.
+    bin: "deepseek-code",
+    // `--turbo` is its "auto-approve all actions" mode (equivalently
+    // `--approval-mode turbo`, alongside plan/default/auto-edit).
+    agentArgs: ["--turbo"],
+    install: { cmd: "npm", args: ["install", "-g", "@serjm/deepseek-code"] },
+  },
   aider: {
     desc: "Aider — pair-programming in your terminal",
     bin: "aider",
@@ -118,6 +146,10 @@ export const ENGINE_ALIASES = {
   cc: "claude", "claude-code": "claude", openai: "codex", gpt: "codex", google: "gemini",
   pc: "privacycode", getprivacycode: "privacycode", privacy: "privacycode",
   "kimi-cli": "kimi", "kimi-code": "kimi", moonshot: "kimi",
+  "qwen-code": "qwen", qwencode: "qwen", alibaba: "qwen",
+  // `dsc` and `deepseek-code` are the binary names the package installs; accept
+  // both as engine names so whichever one someone has seen resolves.
+  ds: "deepseek", dsc: "deepseek", "deepseek-code": "deepseek",
 };
 
 /** Resolve a name/alias to `[key, engine]`, or null. */
@@ -199,6 +231,8 @@ const AI_EXEC = {
   privacycode: (p) => ["run", p],                            // privacycode one-shot (opencode-derived)
   aider: (p) => ["--message", p, "--yes", "--no-auto-commits"], // aider single message
   kimi: (p) => ["-p", p],                                    // kimi prompt mode (prints the response, text by default)
+  qwen: (p) => ["-p", p],                                    // qwen prompt mode (gemini-derived)
+  deepseek: (p) => ["--headless", "-p", p],                  // deepseek: -p runs one prompt and exits; --headless drops the TUI so stdout is pipe-clean
 };
 
 /** argv that runs `prompt` headlessly on `engine` (throws if it has no headless mode). */
@@ -220,7 +254,7 @@ export function aiExecArgs(engine, prompt) {
  */
 export function pickAiEngine(preferred) {
   const wanted = preferred ? resolveEngine(preferred)?.[0] : null;
-  const order = preferred ? (wanted ? [wanted] : []) : ["claude", "codex", "opencode", "privacycode", "gemini", "kimi", "aider"];
+  const order = preferred ? (wanted ? [wanted] : []) : ["claude", "codex", "opencode", "privacycode", "gemini", "kimi", "qwen", "deepseek", "aider"];
   for (const key of order) {
     if (Object.hasOwn(ENGINES, key) && Object.hasOwn(AI_EXEC, key) && isInstalled(ENGINES[key].bin, ENGINES[key].binDirs)) return key;
   }

test/engines.test.mjs

@@ -25,6 +25,8 @@ const EXPECTED_AGENT_ARGS = {
   codex: ["--dangerously-bypass-approvals-and-sandbox"],
   gemini: ["--approval-mode=yolo"],
   kimi: ["--yolo"],
+  qwen: ["--approval-mode=yolo"],
+  deepseek: ["--turbo"],
   aider: ["--yes-always"],
 };
 
@@ -37,6 +39,8 @@ const EXPECTED_LAUNCH_ARGS = {
   codex: ["--dangerously-bypass-approvals-and-sandbox"],
   gemini: ["--approval-mode=yolo"],
   kimi: ["--yolo"], // no agents view — kimi has no agent list to land on
+  qwen: ["--approval-mode=yolo"],
+  deepseek: ["--turbo"],
   aider: ["--yes-always"],
 };
 
@@ -98,10 +102,15 @@ test("every engine declares its reviewed autonomous-mode arguments", () => {
 });
 
 for (const [key, expected] of Object.entries(EXPECTED_LAUNCH_ARGS)) {
+  // The stub has to be named after the engine's *binary*, which is not always
+  // the engine's name — deepseek launches `deepseek-code`. Writing a stub called
+  // `deepseek` would leave nothing on PATH for moshcode to find.
+  const stub = ENGINES[key].bin;
+
   test(`agents ${key} injects its agent-launch args before user arguments`, async () => {
     const nativeBin = tempDir();
     mkdirSync(nativeBin, { recursive: true });
-    writeEngine(nativeBin, key);
+    writeEngine(nativeBin, stub);
 
     const result = await run(["agents", key, "--user-arg", "two words"], nativeBin);
 
@@ -113,7 +122,7 @@ for (const [key, expected] of Object.entries(EXPECTED_LAUNCH_ARGS)) {
   test(`start ${key} injects no arguments`, async () => {
     const nativeBin = tempDir();
     mkdirSync(nativeBin, { recursive: true });
-    writeEngine(nativeBin, key);
+    writeEngine(nativeBin, stub);
 
     const result = await run(["start", key, "--user-arg", "two words"], nativeBin);