@travisennis/acai 0.0.12 → 0.0.13

package/dist/tui/utils.js

@@ -123,6 +123,20 @@ function truncateSimple(text, targetWidth, maxWidth) {
         visibleSoFar: state.visibleSoFar,
     };
 }
+/**
+ * Find the end of the current text segment (until tab or ANSI code).
+ */
+function findSegmentEnd(text, start) {
+    let end = start;
+    while (end < text.length && text[end] !== "\t") {
+        const nextAnsi = extractAnsiCode(text, end);
+        if (nextAnsi) {
+            return end;
+        }
+        end++;
+    }
+    return end;
+}
 function truncateComplex(text, targetWidth, maxWidth) {
     const state = createInitialState();
     let i = 0;
@@ -140,14 +154,7 @@ function truncateComplex(text, targetWidth, maxWidth) {
             continue;
         }
         // Find end of current text segment (until tab or ANSI)
-        let end = i;
-        while (end < text.length && text[end] !== "\t") {
-            const nextAnsi = extractAnsiCode(text, end);
-            if (nextAnsi) {
-                break;
-            }
-            end++;
-        }
+        const end = findSegmentEnd(text, i);
         // Process graphemes in this segment
         for (const { segment } of getSegmenter().segment(text.slice(i, end))) {
             if (processGraphemeSegment(state, segment, targetWidth, maxWidth)) {
@@ -192,12 +199,24 @@ export function truncateToWidth(text, maxWidth, ellipsis = "...", pad = false) {
     }
     // Fast path: pure ASCII printable
     if (isPrintableAscii(text)) {
-        if (text.length <= maxWidth) {
-            return pad ? text + " ".repeat(maxWidth - text.length) : text;
-        }
-        const targetWidth = maxWidth - ellipsisWidth;
-        return finalizeTruncatedResult(text.slice(0, targetWidth), targetWidth, ellipsis, ellipsisWidth, maxWidth, pad);
+        return truncateAscii(text, maxWidth, ellipsis, ellipsisWidth, pad);
+    }
+    return truncateNonAscii(text, maxWidth, ellipsis, ellipsisWidth, pad);
+}
+/**
+ * Truncate ASCII-only text with ellipsis.
+ */
+function truncateAscii(text, maxWidth, ellipsis, ellipsisWidth, pad) {
+    if (text.length <= maxWidth) {
+        return pad ? text + " ".repeat(maxWidth - text.length) : text;
     }
+    const targetWidth = maxWidth - ellipsisWidth;
+    return finalizeTruncatedResult(text.slice(0, targetWidth), targetWidth, ellipsis, ellipsisWidth, maxWidth, pad);
+}
+/**
+ * Truncate text that may contain ANSI codes, tabs, or Unicode wide characters.
+ */
+function truncateNonAscii(text, maxWidth, ellipsis, ellipsisWidth, pad) {
     const targetWidth = maxWidth - ellipsisWidth;
     const hasAnsi = text.includes("\x1b");
     const hasTabs = text.includes("\t");
@@ -221,31 +240,71 @@ export function truncateToWidth(text, maxWidth, ellipsis = "...", pad = false) {
     return finalizeTruncatedResult(truncatedResult.result, truncatedResult.keptWidth, ellipsis, ellipsisWidth, maxWidth, pad);
 }
 /**
- * Truncate a single fragment to a maximum width.
+ * Truncate text that contains only graphemes (no ANSI, no tabs) by
+ * iterating grapheme clusters up to maxWidth.
  */
-function truncateFragmentToWidth(text, maxWidth) {
-    if (maxWidth <= 0 || text.length === 0) {
-        return { text: "", width: 0 };
+function truncateGraphemesOnly(text, maxWidth) {
+    let result = "";
+    let width = 0;
+    for (const { segment } of getSegmenter().segment(text)) {
+        const w = graphemeWidth(segment);
+        if (width + w > maxWidth) {
+            break;
+        }
+        result += segment;
+        width += w;
     }
-    if (isPrintableAscii(text)) {
-        const clipped = text.slice(0, maxWidth);
-        return { text: clipped, width: clipped.length };
+    return { text: result, width };
+}
+/**
+ * Process a contiguous text segment (no tabs, no ANSI codes) within the
+ * larger ANSI/tab-aware truncation loop. Returns the consumed portion and
+ * updated state.
+ */
+function processTextSegment(text, start, maxWidth, currentWidth, pendingAnsi) {
+    // Find end of current text segment (until tab or ANSI code)
+    let end = start;
+    while (end < text.length && text[end] !== "\t") {
+        const nextAnsi = extractAnsiCode(text, end);
+        if (nextAnsi) {
+            break;
+        }
+        end++;
     }
-    const hasAnsi = text.includes("\x1b");
-    const hasTabs = text.includes("\t");
-    if (!hasAnsi && !hasTabs) {
-        let result = "";
-        let width = 0;
-        for (const { segment } of getSegmenter().segment(text)) {
-            const w = graphemeWidth(segment);
-            if (width + w > maxWidth) {
-                break;
-            }
-            result += segment;
-            width += w;
+    let result = "";
+    let width = currentWidth;
+    let pending = pendingAnsi;
+    for (const { segment } of getSegmenter().segment(text.slice(start, end))) {
+        const w = graphemeWidth(segment);
+        if (width + w > maxWidth) {
+            return {
+                text: result,
+                width,
+                pendingAnsi: pending,
+                nextIndex: end,
+                exhausted: true,
+            };
+        }
+        if (pending) {
+            result += pending;
+            pending = "";
         }
-        return { text: result, width };
+        result += segment;
+        width += w;
     }
+    return {
+        text: result,
+        width,
+        pendingAnsi: pending,
+        nextIndex: end,
+        exhausted: false,
+    };
+}
+/**
+ * Truncate text that contains ANSI codes and/or tab characters,
+ * correctly measuring visible width.
+ */
+function truncateWithAnsiAndTabs(text, maxWidth) {
     let result = "";
     let width = 0;
     let i = 0;
@@ -270,30 +329,35 @@ function truncateFragmentToWidth(text, maxWidth) {
             i++;
             continue;
         }
-        let end = i;
-        while (end < text.length && text[end] !== "\t") {
-            const nextAnsi = extractAnsiCode(text, end);
-            if (nextAnsi) {
-                break;
-            }
-            end++;
-        }
-        for (const { segment } of getSegmenter().segment(text.slice(i, end))) {
-            const w = graphemeWidth(segment);
-            if (width + w > maxWidth) {
-                return { text: result, width };
-            }
-            if (pendingAnsi) {
-                result += pendingAnsi;
-                pendingAnsi = "";
-            }
-            result += segment;
-            width += w;
+        const segmentResult = processTextSegment(text, i, maxWidth, width, pendingAnsi);
+        result += segmentResult.text;
+        width = segmentResult.width;
+        pendingAnsi = segmentResult.pendingAnsi;
+        i = segmentResult.nextIndex;
+        if (segmentResult.exhausted) {
+            break;
         }
-        i = end;
     }
     return { text: result, width };
 }
+/**
+ * Truncate a single fragment to a maximum width.
+ */
+export function truncateFragmentToWidth(text, maxWidth) {
+    if (maxWidth <= 0 || text.length === 0) {
+        return { text: "", width: 0 };
+    }
+    if (isPrintableAscii(text)) {
+        const clipped = text.slice(0, maxWidth);
+        return { text: clipped, width: clipped.length };
+    }
+    const hasAnsi = text.includes("\x1b");
+    const hasTabs = text.includes("\t");
+    if (!hasAnsi && !hasTabs) {
+        return truncateGraphemesOnly(text, maxWidth);
+    }
+    return truncateWithAnsiAndTabs(text, maxWidth);
+}
 /**
  * Finalize a truncated result with proper ANSI reset codes.
  * Only adds reset codes if the prefix contains ANSI sequences.

package/dist/utils/bash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bash.d.ts","sourceRoot":"","sources":["../../source/utils/bash.ts"],"names":[],"mappings":"AAuJA,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EAAE,EACrB,GAAG,EAAE,MAAM,GACV;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAiDtC;AAED,eAAO,MAAM,UAAU,GACrB,UAAU,MAAM,GAAG,IAAI,GAAG,SAAS,EACnC,YAAY,MAAM,EAClB,cAAc,MAAM,EAAE,KACrB,MAkEF,CAAC;AA6FF,eAAO,MAAM,iBAAiB,GAAI,YAAY,MAAM,KAAG,OAetD,CAAC"}
+{"version":3,"file":"bash.d.ts","sourceRoot":"","sources":["../../source/utils/bash.ts"],"names":[],"mappings":"AAkNA,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EAAE,EACrB,GAAG,EAAE,MAAM,GACV;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAiBtC;AAiFD,eAAO,MAAM,UAAU,GACrB,UAAU,MAAM,GAAG,IAAI,GAAG,SAAS,EACnC,YAAY,MAAM,EAClB,cAAc,MAAM,EAAE,KACrB,MAaF,CAAC;AA8EF,eAAO,MAAM,iBAAiB,GAAI,YAAY,MAAM,KAAG,OAetD,CAAC"}

package/dist/utils/bash.js

@@ -81,6 +81,33 @@ function isFullyQuoted(token) {
     const last = token[token.length - 1];
     return (first === '"' && last === '"') || (first === "'" && last === "'");
 }
+// Process a single git message flag token and update skip mask
+// Returns true if the token was recognized as a message flag
+function processGitMessageToken(tokens, i, t, skip) {
+    // --message=<msg> - skip this entire token
+    if (t.startsWith("--message=")) {
+        skip[i] = true;
+        return true;
+    }
+    // -m<msg> (attached message) - skip this entire token
+    if (/^-m.+/.test(t)) {
+        skip[i] = true;
+        return true;
+    }
+    // -m or --message consumes next token
+    if (t === "-m" || t === "--message") {
+        if (i + 1 < tokens.length)
+            skip[i + 1] = true;
+        return true;
+    }
+    // Combined short opts containing m, e.g. -am, -avm
+    if (/^-[^-]+$/.test(t) && t.includes("m")) {
+        if (i + 1 < tokens.length)
+            skip[i + 1] = true;
+        return true;
+    }
+    return false;
+}
 // Compute which tokens should be skipped from path validation
 function computeSkipTokenMask(tokens) {
     const skip = new Array(tokens.length).fill(false);
@@ -88,41 +115,52 @@ function computeSkipTokenMask(tokens) {
     const sub = stripQuotes(tokens[1] ?? "");
     // Commands where -m/--message is a string argument (not a path)
     const gitMessageSubs = new Set(["commit", "merge", "tag", "revert", "notes"]);
-    if (bin === "git" && gitMessageSubs.has(sub)) {
-        let seenDoubleDash = false;
-        for (let i = 2; i < tokens.length; i++) {
-            const t = stripQuotes(tokens[i] ?? "");
-            if (t === "--") {
-                seenDoubleDash = true;
-                continue;
-            }
-            if (seenDoubleDash)
-                continue;
-            // --message=<msg> - skip this entire token
-            if (t.startsWith("--message=")) {
-                skip[i] = true;
-                continue;
-            }
-            // -m<msg> (attached message) - skip this entire token
-            if (/^-m.+/.test(t)) {
-                skip[i] = true;
-                continue;
-            }
-            // -m or --message consumes next token
-            if (t === "-m" || t === "--message") {
-                if (i + 1 < tokens.length)
-                    skip[i + 1] = true;
-                continue;
-            }
-            // Combined short opts containing m, e.g. -am, -avm
-            if (/^-[^-]+$/.test(t) && t.includes("m")) {
-                if (i + 1 < tokens.length)
-                    skip[i + 1] = true;
-            }
+    if (bin !== "git" || !gitMessageSubs.has(sub)) {
+        return skip;
+    }
+    let seenDoubleDash = false;
+    for (let i = 2; i < tokens.length; i++) {
+        const t = stripQuotes(tokens[i] ?? "");
+        if (t === "--") {
+            seenDoubleDash = true;
+            continue;
         }
+        if (seenDoubleDash)
+            continue;
+        processGitMessageToken(tokens, i, t, skip);
     }
     return skip;
 }
+function validateToken(token, allowedDirs, cwd) {
+    // Skip fully quoted tokens - they're string arguments, not paths
+    // (paths are typically unquoted or only quoted to handle spaces)
+    if (isFullyQuoted(token) && token.includes("\n")) {
+        return { isValid: true };
+    }
+    // Remove quotes for path checking
+    const cleanToken = stripQuotes(token);
+    // Skip if it's clearly not a path
+    if (cleanToken.startsWith("-") ||
+        cleanToken.includes("://") ||
+        (!cleanToken.includes("/") && cleanToken !== "~")) {
+        return { isValid: true };
+    }
+    try {
+        // Expand ~ to home directory for proper validation
+        const expandedToken = cleanToken.startsWith("~/") || cleanToken === "~"
+            ? path.join(os.homedir(), cleanToken.slice(1))
+            : cleanToken;
+        const resolvedPath = path.resolve(cwd, expandedToken);
+        if (!isPathWithinAllowedDirs(resolvedPath, allowedDirs)) {
+            return {
+                isValid: false,
+                error: `Path '${cleanToken}' resolves outside the allowed directories (${resolvedPath}). All paths must be within ${allowedDirs.join(", ")}`,
+            };
+        }
+    }
+    catch (_e) { }
+    return { isValid: true };
+}
 // Validate path arguments to ensure they're within the project
 export function validatePaths(command, allowedDirs, cwd) {
     const tokens = tokenizeShellWords(command);
@@ -135,75 +173,52 @@ export function validatePaths(command, allowedDirs, cwd) {
         // Skip tokens marked by command-aware logic
         if (skip[i])
             continue;
-        // Skip fully quoted tokens - they're string arguments, not paths
-        // (paths are typically unquoted or only quoted to handle spaces)
-        if (isFullyQuoted(token) && token.includes("\n")) {
-            continue;
-        }
-        // Remove quotes for path checking
-        const cleanToken = stripQuotes(token);
-        // Skip if it's clearly not a path
-        if (cleanToken.startsWith("-") ||
-            cleanToken.includes("://") ||
-            (!cleanToken.includes("/") && cleanToken !== "~")) {
-            continue;
-        }
-        try {
-            // Expand ~ to home directory for proper validation
-            const expandedToken = cleanToken.startsWith("~/") || cleanToken === "~"
-                ? path.join(os.homedir(), cleanToken.slice(1))
-                : cleanToken;
-            const resolvedPath = path.resolve(cwd, expandedToken);
-            if (!isPathWithinAllowedDirs(resolvedPath, allowedDirs)) {
-                return {
-                    isValid: false,
-                    error: `Path '${cleanToken}' resolves outside the allowed directories (${resolvedPath}). All paths must be within ${allowedDirs.join(", ")}`,
-                };
-            }
-        }
-        catch (_e) { }
+        const result = validateToken(token, allowedDirs, cwd);
+        if (!result.isValid)
+            return result;
     }
     return { isValid: true };
 }
-export const resolveCwd = (cwdInput, workingDir, allowedDirs) => {
-    // Determine which directory to use as the base for resolving relative paths
-    // If allowedDirs is provided and non-empty, use the first allowed directory
-    // Otherwise use the workingDir parameter (backward compatibility)
+function resolveBaseDir(allowedDirs, workingDir) {
     const baseDirForResolution = allowedDirs && allowedDirs.length > 0 ? allowedDirs[0] : workingDir;
     const projectRootAbs = path.resolve(baseDirForResolution);
-    let projectRoot = projectRootAbs;
     try {
-        projectRoot = fs.realpathSync(projectRootAbs);
+        return fs.realpathSync(projectRootAbs);
     }
     catch {
-        // Fallback to resolved path
+        return projectRootAbs;
     }
-    const raw = typeof cwdInput === "string" && cwdInput.trim() !== ""
-        ? cwdInput.trim()
-        : projectRoot;
-    const abs = path.isAbsolute(raw) ? raw : path.resolve(projectRoot, raw);
-    let target = abs;
+}
+function resolveRawCwd(cwdInput, projectRoot) {
+    if (typeof cwdInput === "string" && cwdInput.trim() !== "") {
+        const trimmed = cwdInput.trim();
+        return path.isAbsolute(trimmed)
+            ? trimmed
+            : path.resolve(projectRoot, trimmed);
+    }
+    return projectRoot;
+}
+function resolveRealTarget(raw) {
     try {
-        target = fs.realpathSync(abs);
+        return fs.realpathSync(raw);
     }
     catch {
-        // If the path doesn't exist entirely, validate intended path
+        return raw;
     }
-    // Check if within allowed directories if provided, otherwise check project root
-    if (allowedDirs && allowedDirs.length > 0) {
-        if (!isPathWithinAllowedDirs(target, allowedDirs)) {
-            throw new Error(`Working directory must be within the allowed directories: ${allowedDirs.join(", ")}. Received: ${cwdInput ?? "<default>"} -> ${target}`);
-        }
+}
+function assertWithinAllowedDirs(target, allowedDirs, cwdInput) {
+    if (!isPathWithinAllowedDirs(target, allowedDirs)) {
+        throw new Error(`Working directory must be within the allowed directories: ${allowedDirs.join(", ")}. Received: ${cwdInput ?? "<default>"} -> ${target}`);
     }
-    else {
-        // Fallback to original behavior: check within project root
-        const rel = path.relative(projectRoot, target);
-        const inside = rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
-        if (!inside) {
-            throw new Error(`Working directory must be within the project directory: ${projectRoot}. Received: ${cwdInput ?? "<default>"} -> ${target}`);
-        }
+}
+function assertWithinProjectRoot(target, projectRoot, cwdInput) {
+    const rel = path.relative(projectRoot, target);
+    const inside = rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+    if (!inside) {
+        throw new Error(`Working directory must be within the project directory: ${projectRoot}. Received: ${cwdInput ?? "<default>"} -> ${target}`);
     }
-    // Check existence and that it's a directory
+}
+function assertDirectoryExists(target) {
     let stats;
     try {
         stats = fs.statSync(target);
@@ -211,13 +226,26 @@ export const resolveCwd = (cwdInput, workingDir, allowedDirs) => {
     catch (err) {
         const error = err;
         if (error.code === "ENOENT") {
-            throw new Error(`Working directory does not exist: ${target} (from ${cwdInput ?? "<default>"})`);
+            throw new Error(`Working directory does not exist: ${target}`);
         }
         throw error;
     }
     if (!stats.isDirectory()) {
         throw new Error(`Working directory is not a directory: ${target}`);
     }
+    return stats;
+}
+export const resolveCwd = (cwdInput, workingDir, allowedDirs) => {
+    const projectRoot = resolveBaseDir(allowedDirs, workingDir);
+    const raw = resolveRawCwd(cwdInput, projectRoot);
+    const target = resolveRealTarget(raw);
+    if (allowedDirs && allowedDirs.length > 0) {
+        assertWithinAllowedDirs(target, allowedDirs, cwdInput);
+    }
+    else {
+        assertWithinProjectRoot(target, projectRoot, cwdInput);
+    }
+    assertDirectoryExists(target);
     return target;
 };
 const mutatingBinaries = new Set([
@@ -278,27 +306,16 @@ function isSegmentMutating(seg) {
     const bin = tokens[0];
     if (!bin)
         return false;
-    if (tokens.some((t) => actionMutating.has(t))) {
+    if (tokens.some((t) => actionMutating.has(t)))
         return true;
-    }
-    if (bin === "sed" && tokens.some((t) => /^-i/.test(t))) {
+    if (bin === "sed" && tokens.some((t) => /^-i/.test(t)))
         return true;
-    }
-    if (mutatingBinaries.has(bin)) {
+    if (mutatingBinaries.has(bin))
+        return true;
+    if (bin === "git" && tokens[1] && gitMutating.has(tokens[1]))
+        return true;
+    if (packageManagers.has(bin) && tokens[1] && npmMutating.has(tokens[1]))
         return true;
-    }
-    if (bin === "git" && tokens.length > 1) {
-        const sub = tokens[1];
-        if (typeof sub === "string" && gitMutating.has(sub)) {
-            return true;
-        }
-    }
-    if (packageManagers.has(bin) && tokens.length > 1) {
-        const sub = tokens[1];
-        if (typeof sub === "string" && npmMutating.has(sub)) {
-            return true;
-        }
-    }
     return false;
 }
 export const isMutatingCommand = (rawCommand) => {

package/dist/utils/command-protection.d.ts

@@ -8,13 +8,13 @@ export interface BlockedCommandResult {
     command: string;
     tip: string;
 }
-export interface SafeCommandResult {
+interface SafeCommandResult {
     blocked: false;
 }
 /**
  * Result type for command safety check
  */
-export type CommandSafetyResult = BlockedCommandResult | SafeCommandResult;
+type CommandSafetyResult = BlockedCommandResult | SafeCommandResult;
 /**
  * Detects if a command is destructive and should be blocked
  * @param command - The full command string to check
@@ -25,4 +25,5 @@ export declare function detectDestructiveCommand(command: string): CommandSafety
  * Generate a user-friendly blocked command message
  */
 export declare function formatBlockedCommandMessage(result: BlockedCommandResult): string;
+export {};
 //# sourceMappingURL=command-protection.d.ts.map

package/dist/utils/command-protection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"command-protection.d.ts","sourceRoot":"","sources":["../../source/utils/command-protection.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,IAAI,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,KAAK,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,oBAAoB,GAAG,iBAAiB,CAAC;AA0E3E;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,mBAAmB,CA4B7E;AA8WD;;GAEG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,oBAAoB,GAC3B,MAAM,CAQR"}
+{"version":3,"file":"command-protection.d.ts","sourceRoot":"","sources":["../../source/utils/command-protection.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,IAAI,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;CACb;AAED,UAAU,iBAAiB;IACzB,OAAO,EAAE,KAAK,CAAC;CAChB;AAED;;GAEG;AACH,KAAK,mBAAmB,GAAG,oBAAoB,GAAG,iBAAiB,CAAC;AA0EpE;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,mBAAmB,CA4B7E;AAqXD;;GAEG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,oBAAoB,GAC3B,MAAM,CAQR"}

package/dist/utils/command-protection.js

@@ -91,6 +91,34 @@ export function detectDestructiveCommand(command) {
     }
     return { blocked: false };
 }
+/**
+ * Check if a git restore command will discard uncommitted changes
+ * (restore without --staged and not creating a branch with -b)
+ */
+function isDestructiveGitRestore(lowerCommand) {
+    if (!lowerCommand.startsWith("git restore"))
+        return false;
+    if (lowerCommand.includes(" --staged"))
+        return false;
+    const afterRestore = lowerCommand.substring("git restore".length).trim();
+    return !!afterRestore && !afterRestore.startsWith("-b");
+}
+/**
+ * Check if a git branch command uses -D (force delete without merge check)
+ */
+function isDestructiveGitBranchD(command, lowerCommand) {
+    const branchMatch = lowerCommand.match(/git\s+branch\s+-([a-z])/);
+    if (!branchMatch)
+        return false;
+    // Check if the flag in the original command is uppercase
+    const flagInOriginal = command.match(/git\s+branch\s+-([A-Za-z])/i);
+    if (!flagInOriginal)
+        return false;
+    if (flagInOriginal[1] !== flagInOriginal[1].toUpperCase())
+        return false;
+    // Verify this is an actual git branch command, not text inside quotes
+    return isActualGitCommand(command, "branch");
+}
 /**
  * Detect destructive git commands
  */
@@ -116,18 +144,13 @@ function detectDestructiveGitCommands(command) {
         };
     }
     // Block git restore without --staged (discards uncommitted changes)
-    if (lowerCommand.startsWith("git restore") &&
-        !lowerCommand.includes(" --staged")) {
-        // Check if it's restoring files (not branches)
-        const afterRestore = lowerCommand.substring("git restore".length).trim();
-        if (afterRestore && !afterRestore.startsWith("-b")) {
-            return {
-                blocked: true,
-                reason: "git restore <file> (without --staged) discards uncommitted changes",
-                command,
-                tip: "Use 'git restore --staged <file>' to only unstage, or 'git stash' to save changes.",
-            };
-        }
+    if (isDestructiveGitRestore(lowerCommand)) {
+        return {
+            blocked: true,
+            reason: "git restore <file> (without --staged) discards uncommitted changes",
+            command,
+            tip: "Use 'git restore --staged <file>' to only unstage, or 'git stash' to save changes.",
+        };
     }
     // Block git clean -f (force deletes untracked files)
     if (lowerCommand.includes("git clean -f") ||
@@ -151,27 +174,13 @@ function detectDestructiveGitCommands(command) {
         };
     }
     // Block git branch -D (force delete without merge check)
-    // Check for uppercase flag on original command (lowercase -d is safe)
-    // Match 'git' case-insensitively, but preserve case for the flag
-    // Only match if git branch appears as an actual command (not inside quoted strings)
-    const branchMatch = lowerCommand.match(/git\s+branch\s+-([a-z])/);
-    if (branchMatch) {
-        // Check if the flag in the original command is uppercase
-        const flagInOriginal = command.match(/git\s+branch\s+-([A-Za-z])/i);
-        if (flagInOriginal &&
-            flagInOriginal[1] === flagInOriginal[1].toUpperCase()) {
-            // Verify this is an actual git branch command, not text inside quotes
-            // Check if git branch appears at start or after command separators
-            const isActualCommand = isActualGitCommand(command, "branch");
-            if (isActualCommand) {
-                return {
-                    blocked: true,
-                    reason: "git branch -D force-deletes branches without checking if they're merged",
-                    command,
-                    tip: "Use 'git branch -d' (lowercase) to safely delete branches that are merged.",
-                };
-            }
-        }
+    if (isDestructiveGitBranchD(command, lowerCommand)) {
+        return {
+            blocked: true,
+            reason: "git branch -D force-deletes branches without checking if they're merged",
+            command,
+            tip: "Use 'git branch -d' (lowercase) to safely delete branches that are merged.",
+        };
     }
     // Block git stash drop and git stash clear
     if (lowerCommand.includes("git stash drop") ||

package/dist/utils/filesystem/operations.d.ts

@@ -1,18 +1,3 @@
-export declare function toPath(urlOrPath: URL | string): string;
-/**
- * Converts Windows backslashes to POSIX forward slashes.
- * Preserves UNC paths and extended-length paths.
- * @param inputPath - Path to convert
- * @returns Path with forward slashes
- */
-export declare function slash(inputPath: string): string;
-/**
- * Checks if a path exists and is a directory.
- * @param filePath - Path to check (URL or string)
- * @returns Promise resolving to true if path is a directory
- * @throws TypeError if input is invalid
- */
-export declare function isDirectory(filePath: URL | string): Promise<boolean>;
 /**
  * Safely clears all contents of a directory.
  * @param directoryPath - Path to the directory to clear (URL or string)

package/dist/utils/filesystem/operations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operations.d.ts","sourceRoot":"","sources":["../../../source/utils/filesystem/operations.ts"],"names":[],"mappings":"AAIA,wBAAgB,MAAM,CAAC,SAAS,EAAE,GAAG,GAAG,MAAM,GAAG,MAAM,CAEtD;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAS/C;AAED;;;;;GAKG;AACH,wBAAsB,WAAW,CAAC,QAAQ,EAAE,GAAG,GAAG,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAmB1E;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAClC,aAAa,EAAE,GAAG,GAAG,MAAM,GAC1B,OAAO,CAAC,IAAI,CAAC,CAuGf"}
+{"version":3,"file":"operations.d.ts","sourceRoot":"","sources":["../../../source/utils/filesystem/operations.ts"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,wBAAsB,cAAc,CAClC,aAAa,EAAE,GAAG,GAAG,MAAM,GAC1B,OAAO,CAAC,IAAI,CAAC,CAuGf"}