@nemus-cli/nemus 0.2.9 → 0.2.10

package/CHANGELOG.md

@@ -7,6 +7,60 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.10] - 2026-08-27
+
+### Security
+
+- **Eliminated the shell-injection surface in git/shell operations.** Every
+  `exec`/`execSync` call that interpolated a value into a shell string was
+  migrated to `execFile`/argv (no shell). Most notably, the MCP `branch_create`
+  and `switch_branch` tools built `git checkout -b <name>` by unquoted
+  interpolation with no branch-name validation, so a crafted (but valid) git ref
+  could run arbitrary commands; branch names are now passed as argv elements and
+  can never be interpreted by a shell. Also migrated `ghq`/clone, workspace
+  cleanup (`du`, `git clean`), disk-usage health checks, agent-availability
+  probing, and the shell-integration/MCP installers.
+- **`w delete` no longer deletes arbitrary directories.** The `--workspace` flag
+  path validated names through `safeWorkspacePath()` (allowlist + containment)
+  and skips unknown/invalid names instead of `fs.rm`-ing a guessed path; the
+  interactive path is guarded the same way.
+
+### Added
+
+- **Monorepo (npm workspaces).** The repo is now an npm-workspaces monorepo:
+  the published CLI stays at the root (`@nemus-cli/nemus`, unchanged) and new
+  packages live under `packages/*`.
+- **`@nemus-cli/cloud` (private, P1).** An optional, vendor-neutral cloud/IaC
+  package — not required for local Nemus. Two seams so far: the **forge-auth**
+  seam (`ForgeTokenSource`) with `pat` and a dependency-free `github-app` source
+  that mints least-privilege, auto-refreshing installation tokens; and the
+  **execution** seam (`Runner`/`Provisioner` + neutral `TaskSpec`/
+  `TargetDescriptor`/`Capabilities` + a name registry) with an in-box
+  **Docker runner** (needs no cloud account); a **`SecretSource`** seam
+  (`env`/`dotenv`/`gh` + `resolveSecretsToEnv`); and a **`GitForge`** seam
+  (`openPR`/`getChecks`/`comment`) with a dependency-free GitHub implementation;
+  and the **in-image agent orchestrator** (runner-image env contract, versioned
+  `result.json` schema, and `runAgentTask`: clone all → run the agent once over
+  the workspace → open a PR per changed repo, with per-repo error isolation);
+  the **OCI image + `nemus-cloud-agent` entrypoint** (a Dockerfile with node +
+  git + gh + pi/claude); and the **provisioning** seam (P2, in progress): a
+  generic `OpenTofuProvisioner` (delegates to `tofu`/`terraform`, maps a module's
+  `target` output → `TargetDescriptor`) + registry, plus a first **AWS Fargate**
+  OpenTofu module (`iac/fargate/`, validated with real `tofu validate`); and the
+  matching **`aws-fargate` Runner** (dependency-free, shells the `aws` CLI:
+  `register-task-definition` → `run-task`, `describe-tasks` → status, CloudWatch
+  `logs tail` streaming, `stop-task`); and the **`nemus-cloud` CLI** (own bin,
+  dependency-free) — `up`/`down` drive the provisioner, `run` launches the agent
+  image on a target (`--follow` logs, `--wait` for the exit code). This
+  completes P2. **P3 (in progress):** a bounded **CI-loop** (`runCiLoop`) that
+  drives a PR to green over `GitForge` — poll checks, run a fix pass on failure,
+  commit/push, repeat; anti-runaway guards (max iterations, no-change → stuck,
+  poll-budget → timeout) + a best-effort "needs a human" give-up comment; and
+  (P4) a vendor-neutral **notification seam** — `Notifier` with Slack (incoming
+  webhook) + generic webhook sinks (`notifierFromEnv`), wired into the CI-loop as
+  optional out-of-band report-back.
+  Design: `docs/plans/2026-08-26-cloud-iac.md`.
+
 ## [0.2.9] - 2026-08-26
 
 ### Fixed

package/README.md

@@ -3,46 +3,82 @@
 </p>
 
 <p align="center">
-  <b>Multi-repo workspaces for the AI-agent era.</b><br/>
-  Create, sync, and operate across dozens of Git repositories with a single command —
-  and wire them up to your favorite coding agent.
+  <b>Work on many Git repos as if they were one project.</b><br/>
+  Nemus pulls the repos you're working on into a single folder, runs commands across
+  all of them at once, and gives your AI coding agent the whole picture.
 </p>
 
 <p align="center">
+  <a href="https://me-public.github.io/nemus/"><img src="https://img.shields.io/badge/website-nemus-3FB950.svg" alt="Website" /></a>
   <a href="https://github.com/me-public/nemus/actions/workflows/ci.yml"><img src="https://github.com/me-public/nemus/actions/workflows/ci.yml/badge.svg" alt="CI" /></a>
   <a href="https://www.npmjs.com/package/@nemus-cli/nemus"><img src="https://img.shields.io/npm/v/@nemus-cli/nemus.svg" alt="npm" /></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="License: MIT" /></a>
   <a href="https://www.npmjs.com/package/@nemus-cli/nemus"><img src="https://img.shields.io/npm/dm/@nemus-cli/nemus.svg" alt="npm downloads" /></a>
   <img src="https://img.shields.io/badge/node-%3E%3D22-brightgreen.svg" alt="Node >= 22" />
+  <a href="https://x.com/nemus_cli"><img src="https://img.shields.io/badge/follow-%40nemus__cli-000000.svg?logo=x&logoColor=white" alt="Follow @nemus_cli on X" /></a>
 </p>
 
 <p align="center">
-  📦 <b><a href="https://www.npmjs.com/package/@nemus-cli/nemus">@nemus-cli/nemus</a></b> on npm &nbsp;—&nbsp; <code>npm install -g @nemus-cli/nemus</code>
+  🌐 <b><a href="https://me-public.github.io/nemus/">me-public.github.io/nemus</a></b> &nbsp;—&nbsp; 📦 <b><a href="https://www.npmjs.com/package/@nemus-cli/nemus">@nemus-cli/nemus</a></b> on npm &nbsp;—&nbsp; 𝕏 <b><a href="https://x.com/nemus_cli">@nemus_cli</a></b> &nbsp;—&nbsp; <code>npm install -g @nemus-cli/nemus</code>
 </p>
 
+<p align="center">
+  <a href="https://raw.githubusercontent.com/me-public/nemus/main/docs/assets/nemus-cli-demo.mp4"><img src="https://raw.githubusercontent.com/me-public/nemus/main/docs/assets/nemus-cli-demo.gif" alt="Nemus terminal demo — describe a workspace in plain English, Nemus clones the repos and writes the agent context, then run across every repo at once" width="820" /></a>
+</p>
+<p align="center"><sub>A real recording — <code>nemus -- "…"</code> turns a sentence into a ready workspace. <a href="https://raw.githubusercontent.com/me-public/nemus/main/docs/assets/nemus-cli-demo.mp4">▶ watch as MP4</a></sub></p>
+
 ---
 
-## The name
+## What is Nemus?
 
-**Nemus** (_NEH-mus_) is Latin for a **grove** — a small wood of trees sharing
-soil and roots. It's a fitting picture of what the tool manages: a cluster of
-repositories, each its own tree, growing together in one workspace. It also nods
-to the branch-and-commit shape of Git itself.
+Your product's code is probably split across **many separate Git repos** — frontend,
+backend, auth, payments, shared libraries. Working on one feature means cloning,
+pulling, branching, and testing each repo by hand, one at a time — and your AI coding
+agent only ever sees the single repo you happened to open.
+
+**Nemus lets you pull the repos you're working on into one folder and treat them as a
+single project:**
+
+- **One command clones them all** — and keeps them in sync.
+- **Run any git or shell command across every repo at once** — `status`, `pull`,
+  `branch`, `npm test`, anything.
+- **Your AI agent sees the whole set at once** — so a prompt like *"add idempotency
+  keys to the payments flow"* works even when that flow spans five repos, not one.
+
+> **In short:** a **monorepo-style workflow across your many repos — without merging them.**
+
+### Before vs. after
 
-## Why Nemus?
+**Without Nemus** — clone each repo by hand, `cd` into every one, pull, branch, run
+tests, and repeat. Your agent only sees whichever repo you opened.
 
-Modern products span many repositories. Nemus keeps a **workspace** — a named folder
-of related repos — in sync and lets you act across all of them at once: clone, pull,
-branch, run commands, check status, and diff. Then it connects that workspace to a
-coding agent (Claude Code, pi, OpenCode, Codex, Gemini) with generated context files,
-skills, and an MCP server, so "work on the payments stack" becomes a single prompt.
+**With Nemus:**
 
-- 🌳 **Workspaces** — group repos, clone them all, jump in.
+```bash
+nemus create -w payments -r api,web,ledger,gateway,workers   # clone all 5 into one workspace
+nemus run payments "npm test"                                # run the tests in all 5 at once
+nemus -- "add idempotency keys to the payments flow"         # let an agent work across all 5
+```
+
+> Prefer to point-and-pick? Just run `nemus create` for an interactive repo picker with
+> fuzzy search, or `nemus -- "create a workspace with the payments repos"` in plain English.
+
+## What you get
+
+- 🌳 **Workspaces** — group repos, clone them all in parallel, jump in.
 - 🔁 **Operate in bulk** — status, sync, diff, run, branch across every repo.
 - 📦 **Suites & snapshots** — save reusable repo collections and exact states.
-- 🤖 **Agent-native** — first-class integration with multiple coding agents.
+- 🤖 **Agent-native** — first-class integration with multiple coding agents
+  (Claude Code, pi, OpenCode, Codex, Gemini) via context files, skills, and an MCP server.
 - 🩺 **Healthy by default** — health checks, dependency analysis, retries.
 
+## The name
+
+**Nemus** (_NEH-mus_) is Latin for a **grove** — a small wood of trees sharing
+soil and roots. It's a fitting picture of what the tool manages: a cluster of
+repositories, each its own tree, growing together in one workspace. It also nods
+to the branch-and-commit shape of Git itself.
+
 ## A full clone per workspace — on purpose
 
 This is the core design decision, so it's worth being explicit: **every workspace

package/dist/cli/ai-prompt.js

@@ -50,7 +50,7 @@ const logger_1 = require("../utils/logger");
 const colors_1 = require("../utils/colors");
 const agent_config_1 = require("../utils/agent-config");
 const validation_1 = require("../utils/validation");
-const execAsync = (0, util_1.promisify)(child_process_1.exec);
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
 exports.AI_PROMPT_FILE = path.join(os.homedir(), '.workspace-ai-prompt');
 const EXTRACT_SCHEMA = JSON.stringify({
     type: 'object',
@@ -129,7 +129,7 @@ function buildInvestigationPreamble(workspaceName, task, opts = {}) {
 async function isPrimaryAgentAvailable() {
     const agent = (0, agent_config_1.getPrimaryAgent)();
     try {
-        await execAsync(`which ${agent.launchCommand}`);
+        await execFileAsync('which', [agent.launchCommand]);
         return true;
     }
     catch {

package/dist/commands/configure.js

@@ -148,7 +148,7 @@ async function handleConfigure() {
             (0, logger_1.logInfo)('Installing MCP server...');
             try {
                 const mcpInstallScript = path.join(__dirname, '..', '..', 'dist', 'mcp', 'install.js');
-                (0, child_process_1.execSync)(`node "${mcpInstallScript}" install`, { stdio: 'inherit' });
+                (0, child_process_1.execFileSync)('node', [mcpInstallScript, 'install'], { stdio: 'inherit' });
                 mcpInstalled = true;
             }
             catch {
@@ -198,7 +198,7 @@ function installShellIntegration() {
         return;
     }
     try {
-        (0, child_process_1.execSync)(`bash "${scriptPath}" ${shellType}`, { stdio: 'inherit' });
+        (0, child_process_1.execFileSync)('bash', [scriptPath, shellType], { stdio: 'inherit' });
     }
     catch {
         (0, logger_1.logWarning)('Shell integration install failed — you can run it manually:');

package/dist/commands/delete.js

@@ -39,8 +39,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerDeleteCommand = registerDeleteCommand;
 exports.main = main;
 const fs = __importStar(require("fs/promises"));
-const config_1 = require("../utils/config");
-const path = __importStar(require("path"));
+const validation_1 = require("../utils/validation");
 const workspace_meta_1 = require("../utils/workspace-meta");
 const prompts_1 = require("../utils/prompts");
 const logger_1 = require("../utils/logger");
@@ -67,9 +66,33 @@ async function handleDelete(opts) {
         if (opts.workspace) {
             const selectedNames = (0, command_helpers_1.parseList)(opts.workspace);
             const workspaces = await (0, workspace_meta_1.listWorkspaces)();
+            const known = new Map(workspaces.map(ws => [ws.name, ws]));
+            // Resolve to validated, existing targets. safeWorkspacePath() both
+            // enforces the name allowlist and pins the path inside WORKSPACES_DIR, so
+            // a name like "../../etc" can never reach fs.rm; unknown names are skipped
+            // rather than deleted at a guessed path.
+            const targets = [];
             for (const name of selectedNames) {
-                const workspace = workspaces.find(ws => ws.name === name);
-                const workspacePath = path.join(config_1.WORKSPACES_DIR, name);
+                const workspace = known.get(name);
+                if (!workspace) {
+                    (0, logger_1.logError)(`Workspace "${name}" not found — skipping`);
+                    continue;
+                }
+                let workspacePath;
+                try {
+                    workspacePath = (0, validation_1.safeWorkspacePath)(name);
+                }
+                catch (error) {
+                    (0, logger_1.logError)(error instanceof Error ? error.message : `Invalid workspace name "${name}"`);
+                    continue;
+                }
+                targets.push({ name, path: workspacePath, workspace });
+            }
+            if (targets.length === 0) {
+                (0, logger_1.logInfo)('Nothing to delete');
+                return;
+            }
+            for (const { name, path: workspacePath, workspace } of targets) {
                 if (workspace?.metadata) {
                     console.log(`${(0, colors_1.colorize)(name, 'cyan')}`);
                     console.log(`  Repositories: ${workspace.metadata.repositories.length}`);
@@ -86,9 +109,9 @@ async function handleDelete(opts) {
                     {
                         type: 'confirm',
                         name: 'confirmed',
-                        message: selectedNames.length === 1
-                            ? `Delete workspace ${selectedNames[0]}?`
-                            : `Delete these ${selectedNames.length} workspaces?`,
+                        message: targets.length === 1
+                            ? `Delete workspace ${targets[0].name}?`
+                            : `Delete these ${targets.length} workspaces?`,
                         default: true,
                     },
                 ]);
@@ -97,8 +120,7 @@ async function handleDelete(opts) {
                     process.exit(0);
                 }
             }
-            for (const name of selectedNames) {
-                const workspacePath = path.join(config_1.WORKSPACES_DIR, name);
+            for (const { name, path: workspacePath } of targets) {
                 try {
                     await fs.rm(workspacePath, { recursive: true, force: true });
                     (0, logger_1.logSuccess)(`Deleted "${(0, colors_1.colorize)(name, 'cyan')}"`);
@@ -119,44 +141,55 @@ async function handleDelete(opts) {
                 break;
             }
             const selectedNames = await (0, prompts_1.promptMultiWorkspaceSelection)(workspaces);
+            // Resolve + validate paths once. Names come from disk, but safeWorkspacePath
+            // must not throw mid-flow and crash the interactive session, so skip any
+            // name that fails the allowlist rather than aborting.
+            const resolved = [];
             for (const name of selectedNames) {
-                const workspace = workspaces.find(ws => ws.name === name);
-                const workspacePath = path.join(config_1.WORKSPACES_DIR, name);
-                if (workspace?.metadata) {
-                    console.log(`${(0, colors_1.colorize)(name, 'cyan')}`);
-                    console.log(`  Repositories: ${workspace.metadata.repositories.length}`);
-                    console.log(`  Created: ${new Date(workspace.metadata.createdAt).toLocaleString()}`);
-                    console.log(`  Path: ${workspacePath}`);
+                try {
+                    resolved.push({ name, path: (0, validation_1.safeWorkspacePath)(name), workspace: workspaces.find(ws => ws.name === name) });
                 }
-                else {
-                    console.log(`${(0, colors_1.colorize)(name, 'cyan')}`);
-                    console.log(`  Path: ${workspacePath}`);
+                catch (error) {
+                    (0, logger_1.logError)(error instanceof Error ? error.message : `Invalid workspace name "${name}"`);
                 }
             }
-            console.log('');
-            (0, logger_1.logWarning)('This will permanently delete all cloned repositories in the selected workspaces!');
-            const confirmMessage = selectedNames.length === 1
-                ? `Delete workspace ${selectedNames[0]}?`
-                : `Delete these ${selectedNames.length} workspaces?`;
-            const { confirmed } = await inquirer_1.default.prompt([
-                {
-                    type: 'confirm',
-                    name: 'confirmed',
-                    message: confirmMessage,
-                    default: true,
-                },
-            ]);
-            if (confirmed) {
-                for (const name of selectedNames) {
-                    const workspacePath = path.join(config_1.WORKSPACES_DIR, name);
-                    try {
-                        await fs.rm(workspacePath, { recursive: true, force: true });
-                        (0, logger_1.logSuccess)(`Deleted "${(0, colors_1.colorize)(name, 'cyan')}"`);
+            if (resolved.length > 0) {
+                for (const { name, path: workspacePath, workspace } of resolved) {
+                    if (workspace?.metadata) {
+                        console.log(`${(0, colors_1.colorize)(name, 'cyan')}`);
+                        console.log(`  Repositories: ${workspace.metadata.repositories.length}`);
+                        console.log(`  Created: ${new Date(workspace.metadata.createdAt).toLocaleString()}`);
+                        console.log(`  Path: ${workspacePath}`);
+                    }
+                    else {
+                        console.log(`${(0, colors_1.colorize)(name, 'cyan')}`);
+                        console.log(`  Path: ${workspacePath}`);
                     }
-                    catch (error) {
-                        (0, logger_1.logError)(`Failed to delete "${name}"`);
-                        if (error instanceof Error)
-                            (0, logger_1.logError)(error.message);
+                }
+                console.log('');
+                (0, logger_1.logWarning)('This will permanently delete all cloned repositories in the selected workspaces!');
+                const confirmMessage = resolved.length === 1
+                    ? `Delete workspace ${resolved[0].name}?`
+                    : `Delete these ${resolved.length} workspaces?`;
+                const { confirmed } = await inquirer_1.default.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'confirmed',
+                        message: confirmMessage,
+                        default: true,
+                    },
+                ]);
+                if (confirmed) {
+                    for (const { name, path: workspacePath } of resolved) {
+                        try {
+                            await fs.rm(workspacePath, { recursive: true, force: true });
+                            (0, logger_1.logSuccess)(`Deleted "${(0, colors_1.colorize)(name, 'cyan')}"`);
+                        }
+                        catch (error) {
+                            (0, logger_1.logError)(`Failed to delete "${name}"`);
+                            if (error instanceof Error)
+                                (0, logger_1.logError)(error.message);
+                        }
                     }
                 }
             }

package/dist/mcp/install.js

@@ -70,7 +70,7 @@ function installShellIntegration() {
         return;
     }
     try {
-        (0, child_process_1.execSync)(`bash "${scriptPath}" ${shellType}`, { stdio: 'inherit' });
+        (0, child_process_1.execFileSync)('bash', [scriptPath, shellType], { stdio: 'inherit' });
         (0, logger_1.logSuccess)('Shell integration installed (auto-CD for w/workspace commands)');
     }
     catch {
@@ -294,7 +294,7 @@ async function install() {
         const serverPath = getMcpServerPath();
         (0, logger_1.logInfo)(`MCP server path: ${(0, colors_1.colorize)(serverPath, 'cyan')}`);
         try {
-            (0, child_process_1.execSync)(`claude mcp add nemus -s user -- node "${serverPath}"`, { stdio: 'pipe' });
+            (0, child_process_1.execFileSync)('claude', ['mcp', 'add', 'nemus', '-s', 'user', '--', 'node', serverPath], { stdio: 'pipe' });
             (0, logger_1.logSuccess)('MCP server registered globally with Claude Code');
             console.log('\nYou can now use nemus tools in any Claude Code session.');
             console.log('Try asking: "list my workspaces" or "what\'s the status of my-workspace"');

package/dist/utils/branch-operations.js

@@ -38,7 +38,10 @@ const child_process_1 = require("child_process");
 const util_1 = require("util");
 const fs = __importStar(require("fs/promises"));
 const git_status_1 = require("./git-status");
-const execAsync = (0, util_1.promisify)(child_process_1.exec);
+// execFile (no shell): git args are passed as an argv array, so a branch name
+// containing shell metacharacters can never be interpreted as a command.
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+const git = (args, opts) => execFileAsync('git', args, opts);
 const GIT_TIMEOUT = 30000;
 const switchBranch = async (repoPath, repoName, targetBranch) => {
     try {
@@ -55,7 +58,7 @@ const switchBranch = async (repoPath, repoName, targetBranch) => {
         }
         // Check if it's a git repository
         try {
-            await execAsync('git rev-parse --git-dir', { cwd: repoPath });
+            await git(['rev-parse', '--git-dir'], { cwd: repoPath });
         }
         catch {
             return {
@@ -65,7 +68,7 @@ const switchBranch = async (repoPath, repoName, targetBranch) => {
             };
         }
         // Get current branch
-        const { stdout: currentBranchOutput } = await execAsync('git branch --show-current', { cwd: repoPath });
+        const { stdout: currentBranchOutput } = await git(['branch', '--show-current'], { cwd: repoPath });
         const currentBranch = currentBranchOutput.trim();
         if (currentBranch === targetBranch) {
             return {
@@ -76,7 +79,7 @@ const switchBranch = async (repoPath, repoName, targetBranch) => {
             };
         }
         // Check for uncommitted changes
-        const { stdout: statusOutput } = await execAsync('git status --porcelain', { cwd: repoPath });
+        const { stdout: statusOutput } = await git(['status', '--porcelain'], { cwd: repoPath });
         if (statusOutput.trim().length > 0) {
             return {
                 repo: repoName,
@@ -86,17 +89,17 @@ const switchBranch = async (repoPath, repoName, targetBranch) => {
             };
         }
         // Fetch to ensure we have latest branches
-        await execAsync('git fetch', { cwd: repoPath, timeout: GIT_TIMEOUT });
+        await git(['fetch'], { cwd: repoPath, timeout: GIT_TIMEOUT });
         // Check if branch exists locally
         try {
-            await execAsync(`git rev-parse --verify ${targetBranch}`, { cwd: repoPath });
+            await git(['rev-parse', '--verify', targetBranch], { cwd: repoPath });
         }
         catch {
             // Branch doesn't exist locally, check remote
             try {
-                await execAsync(`git rev-parse --verify origin/${targetBranch}`, { cwd: repoPath });
+                await git(['rev-parse', '--verify', `origin/${targetBranch}`], { cwd: repoPath });
                 // Branch exists on remote, create local tracking branch
-                await execAsync(`git checkout -b ${targetBranch} origin/${targetBranch}`, { cwd: repoPath });
+                await git(['checkout', '-b', targetBranch, `origin/${targetBranch}`], { cwd: repoPath });
                 return {
                     repo: repoName,
                     status: 'success',
@@ -114,7 +117,7 @@ const switchBranch = async (repoPath, repoName, targetBranch) => {
             }
         }
         // Switch to existing local branch
-        await execAsync(`git checkout ${targetBranch}`, { cwd: repoPath });
+        await git(['checkout', targetBranch], { cwd: repoPath });
         return {
             repo: repoName,
             status: 'success',
@@ -147,16 +150,10 @@ const createBranch = async (repoPath, repoName, branchName, baseBranch, force) =
         }
         // Checkout base branch if specified
         if (baseBranch) {
-            await execAsync(`git checkout ${baseBranch}`, {
-                cwd: repoPath,
-                timeout: GIT_TIMEOUT,
-            });
+            await git(['checkout', baseBranch], { cwd: repoPath, timeout: GIT_TIMEOUT });
         }
         // Create and checkout new branch
-        await execAsync(`git checkout -b ${branchName}`, {
-            cwd: repoPath,
-            timeout: GIT_TIMEOUT,
-        });
+        await git(['checkout', '-b', branchName], { cwd: repoPath, timeout: GIT_TIMEOUT });
         return {
             repo: repoName,
             success: true,
@@ -176,22 +173,16 @@ exports.createBranch = createBranch;
 const mergeBranch = async (repoPath, repoName, sourceBranch, targetBranch, options) => {
     try {
         // Checkout target branch
-        await execAsync(`git checkout ${targetBranch}`, {
-            cwd: repoPath,
-            timeout: GIT_TIMEOUT,
-        });
-        // Build merge command
-        let mergeCmd = `git merge ${sourceBranch}`;
+        await git(['checkout', targetBranch], { cwd: repoPath, timeout: GIT_TIMEOUT });
+        // Build merge argv
+        const mergeArgs = ['merge', sourceBranch];
         if (options?.noFf)
-            mergeCmd += ' --no-ff';
+            mergeArgs.push('--no-ff');
         if (options?.ffOnly)
-            mergeCmd += ' --ff-only';
+            mergeArgs.push('--ff-only');
         if (options?.squash)
-            mergeCmd += ' --squash';
-        await execAsync(mergeCmd, {
-            cwd: repoPath,
-            timeout: GIT_TIMEOUT,
-        });
+            mergeArgs.push('--squash');
+        await git(mergeArgs, { cwd: repoPath, timeout: GIT_TIMEOUT });
         return {
             repo: repoName,
             success: true,
@@ -210,10 +201,7 @@ const mergeBranch = async (repoPath, repoName, sourceBranch, targetBranch, optio
 exports.mergeBranch = mergeBranch;
 const rebaseBranch = async (repoPath, repoName, targetBranch) => {
     try {
-        await execAsync(`git rebase ${targetBranch}`, {
-            cwd: repoPath,
-            timeout: GIT_TIMEOUT,
-        });
+        await git(['rebase', targetBranch], { cwd: repoPath, timeout: GIT_TIMEOUT });
         return {
             repo: repoName,
             success: true,

package/dist/utils/cleanup-operations.js

@@ -38,10 +38,10 @@ const child_process_1 = require("child_process");
 const util_1 = require("util");
 const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
-const execAsync = (0, util_1.promisify)(child_process_1.exec);
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
 const calculateDirSize = async (dirPath) => {
     try {
-        const { stdout } = await execAsync(`du -sk "${dirPath}"`);
+        const { stdout } = await execFileAsync('du', ['-sk', dirPath]);
         const sizeInKB = parseInt(stdout.split('\t')[0], 10);
         return sizeInKB;
     }
@@ -98,9 +98,9 @@ const removeBuildArtifacts = async (repoPath) => {
 exports.removeBuildArtifacts = removeBuildArtifacts;
 const gitClean = async (repoPath, dryRun = false) => {
     try {
-        const cmd = dryRun ? 'git clean -fdxn' : 'git clean -fdx';
-        const { stdout } = await execAsync(cmd, { cwd: repoPath });
-        const lines = stdout.split('\n').filter(l => l.trim());
+        const args = dryRun ? ['clean', '-fdxn'] : ['clean', '-fdx'];
+        const { stdout } = await execFileAsync('git', args, { cwd: repoPath });
+        const lines = stdout.split('\n').filter((l) => l.trim());
         return {
             operation: 'Git clean',
             filesRemoved: lines.length,