@travisennis/acai 0.0.9 → 0.0.11

package/dist/utils/command-protection.js

@@ -0,0 +1,324 @@
+/**
+ * Command Protection Module
+ * Detects and blocks destructive commands that could cause data loss
+ */
+/**
+ * Detects if a command is destructive and should be blocked
+ * @param command - The full command string to check
+ * @returns BlockedCommandResult if destructive, SafeCommandResult if safe
+ */
+export function detectDestructiveCommand(command) {
+    const trimmed = command.trim();
+    // Check for dangerous inline scripts first (bash -c, python -c, etc.)
+    const inlineScriptResult = detectDangerousInlineScripts(trimmed);
+    if (inlineScriptResult.blocked) {
+        return inlineScriptResult;
+    }
+    // Check for dangerous heredocs
+    const heredocResult = detectDangerousHeredocs(trimmed);
+    if (heredocResult.blocked) {
+        return heredocResult;
+    }
+    // Check for destructive git commands
+    const gitResult = detectDestructiveGitCommands(trimmed);
+    if (gitResult.blocked) {
+        return gitResult;
+    }
+    // Check for dangerous rm -rf commands
+    const rmResult = detectDangerousRmRf(trimmed);
+    if (rmResult.blocked) {
+        return rmResult;
+    }
+    return { blocked: false };
+}
+/**
+ * Detect destructive git commands
+ */
+function detectDestructiveGitCommands(command) {
+    const lowerCommand = command.toLowerCase();
+    // Block git reset --hard and --merge
+    if (lowerCommand.includes("git reset --hard") ||
+        lowerCommand.includes("git reset --merge")) {
+        return {
+            blocked: true,
+            reason: "git reset --hard or --merge destroys uncommitted changes",
+            command,
+            tip: "Consider using 'git stash' first to save your changes, or use 'git reset --soft' to preserve changes.",
+        };
+    }
+    // Block git checkout -- <file> (discarding local changes)
+    if (lowerCommand.match(/git\s+checkout\s+--\s+\S+/)) {
+        return {
+            blocked: true,
+            reason: "git checkout -- <file> discards uncommitted file changes",
+            command,
+            tip: "Use 'git restore --staged <file>' to unstage changes, or 'git stash' to save changes temporarily.",
+        };
+    }
+    // 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.",
+            };
+        }
+    }
+    // Block git clean -f (force deletes untracked files)
+    if (lowerCommand.includes("git clean -f") ||
+        lowerCommand.includes("git clean --force")) {
+        return {
+            blocked: true,
+            reason: "git clean -f permanently deletes untracked files",
+            command,
+            tip: "Use 'git clean -n' to preview what would be deleted, or 'git clean -f -d' to only delete untracked directories.",
+        };
+    }
+    // Block force push (but allow --force-with-lease which is safer)
+    if ((lowerCommand.includes("git push --force") &&
+        !lowerCommand.includes("--force-with-lease")) ||
+        lowerCommand.match(/git\s+push\s+-f\b/)) {
+        return {
+            blocked: true,
+            reason: "git push --force overwrites remote commit history",
+            command,
+            tip: "Use 'git push --force-with-lease' for safer force pushes, or prefer creating a new branch instead.",
+        };
+    }
+    // Block git branch -D (force delete without merge check)
+    if (lowerCommand.match(/git\s+branch\s+-[a-z]/)) {
+        // Check if it's an uppercase letter (force delete)
+        const match = lowerCommand.match(/git\s+branch\s+-[a-z]/);
+        if (match && match[0].slice(-1) !== match[0].slice(-1).toLowerCase()) {
+            // It's uppercase, block it
+        }
+        else if (match) {
+            const upperMatch = command.match(/git\s+branch\s+-[A-Z]/);
+            if (upperMatch) {
+                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") ||
+        lowerCommand.includes("git stash clear")) {
+        return {
+            blocked: true,
+            reason: "git stash drop/clear permanently deletes stashed changes",
+            command,
+            tip: "Use 'git stash list' to see stashes, or 'git stash pop' to apply and remove a stash.",
+        };
+    }
+    return { blocked: false };
+}
+/**
+ * Detect dangerous rm -rf commands outside of temporary directories
+ */
+function detectDangerousRmRf(command) {
+    // Check for rm -rf pattern (case insensitive)
+    const rmMatch = command.match(/rm\s+-rf\s+/i);
+    if (!rmMatch || rmMatch.index === undefined) {
+        return { blocked: false };
+    }
+    // Extract the path argument
+    const matchIndex = rmMatch.index + rmMatch[0].length;
+    const afterRmRf = command.substring(matchIndex).trim();
+    // If no path specified, don't block (will fail naturally)
+    if (!afterRmRf) {
+        return { blocked: false };
+    }
+    // Get temporary directory paths
+    const tempDirs = ["/tmp", "/var/tmp", process.env["TMPDIR"] || "/tmp"];
+    // Check if the path is explicitly targeting only temp directories
+    // This handles: rm -rf /tmp/*, rm -rf /var/tmp/*, rm -rf $TMPDIR/*, and any subpaths
+    const isTempDirectoryOnly = tempDirs.some((tempDir) => {
+        // Check if path starts with temp directory (e.g., /tmp/foo, /tmp/*)
+        if (afterRmRf === tempDir || afterRmRf.startsWith(`${tempDir}/`)) {
+            return true;
+        }
+        return false;
+    });
+    // Also check for $TMPDIR/* pattern (literal strings)
+    // Using string concatenation to avoid lint warnings about template-like strings
+    const tmpDirVar = "$" + "TMPDIR";
+    const tmpDirVarBraces = "$" + "{TMPDIR}";
+    if (afterRmRf === tmpDirVar ||
+        afterRmRf.startsWith(`${tmpDirVar}/`) ||
+        afterRmRf === tmpDirVarBraces ||
+        afterRmRf.startsWith(`${tmpDirVarBraces}/`)) {
+        return { blocked: false };
+    }
+    if (isTempDirectoryOnly) {
+        return { blocked: false };
+    }
+    // Block any other rm -rf
+    return {
+        blocked: true,
+        reason: "rm -rf outside of temporary directories can cause permanent data loss",
+        command,
+        tip: "Only rm -rf is allowed for /tmp/*, /var/tmp/*, or $TMPDIR/* to clean temporary files.",
+    };
+}
+/**
+ * Detect dangerous patterns in inline scripts (-c flags)
+ */
+function detectDangerousInlineScripts(command) {
+    // Check for common inline script patterns and scan the content after -c for destructive commands
+    const languagePatterns = [
+        { pattern: /\bbash\s+-c\s+\S+/i, language: "bash" },
+        { pattern: /\bsh\s+-c\s+\S+/i, language: "sh" },
+        { pattern: /\bpython\d?\s+-c\s+\S+/i, language: "Python" },
+        { pattern: /\bnode\s+-e\s+\S+/i, language: "Node.js" },
+        { pattern: /\bnpx\s+-c\s+\S+/i, language: "npx" },
+        { pattern: /\bruby\s+-e\s+\S+/i, language: "Ruby" },
+        { pattern: /\bperl\s+-e\s+\S+/i, language: "Perl" },
+    ];
+    for (const { pattern, language } of languagePatterns) {
+        if (pattern.test(command)) {
+            // Found an inline script, scan the command for destructive patterns
+            // Look for patterns after -c flag, handling nested quotes
+            const destructivePatterns = [
+                /git\s+reset\s+--hard/i,
+                /git\s+reset\s+--merge/i,
+                /git\s+clean\s+-f/i,
+                /git\s+checkout\s+--\s+\S+/i,
+                /git\s+push\s+(-f|--force)/i,
+                /git\s+branch\s+-[A-Z]/i,
+                /git\s+stash\s+(drop|clear)/i,
+                /rm\s+-rf\s+\/home/i,
+                /rm\s+-rf\s+\/usr/i,
+                /rm\s+-rf\s+~/i,
+            ];
+            // Check if any destructive pattern is present in the command
+            for (const destructivePattern of destructivePatterns) {
+                if (destructivePattern.test(command)) {
+                    return {
+                        blocked: true,
+                        reason: `Inline ${language} script contains destructive operation`,
+                        command,
+                        tip: "Review the script content for destructive commands.",
+                    };
+                }
+            }
+        }
+    }
+    return { blocked: false };
+}
+/**
+ * Detect dangerous patterns in heredocs and here-strings
+ */
+function detectDangerousHeredocs(command) {
+    // Match heredoc patterns: <<EOF ... EOF
+    const heredocPattern = /<<-?\s*['"]?(\w+)['"]?\s*([\s\S]*?)\n\1\b/gi;
+    let match = null;
+    match = heredocPattern.exec(command);
+    while (match !== null) {
+        const heredocContent = match[2];
+        const heredocResult = detectDangerousScriptContent(heredocContent);
+        if (heredocResult.blocked) {
+            return {
+                blocked: true,
+                reason: "Heredoc contains destructive operation",
+                command,
+                tip: heredocResult.tip ||
+                    "Review the heredoc content for destructive commands.",
+            };
+        }
+        match = heredocPattern.exec(command);
+    }
+    // Match here-string patterns (<<<)
+    const hereStringPattern = /<<<\s*(['"])([^"']+)\1/gi;
+    match = null;
+    match = hereStringPattern.exec(command);
+    while (match !== null) {
+        const stringContent = match[2];
+        const stringResult = detectDangerousScriptContent(stringContent);
+        if (stringResult.blocked) {
+            return {
+                blocked: true,
+                reason: "Here-string contains destructive operation",
+                command,
+                tip: stringResult.tip ||
+                    "Review the here-string content for destructive commands.",
+            };
+        }
+        match = hereStringPattern.exec(command);
+    }
+    return { blocked: false };
+}
+/**
+ * Check script content for dangerous patterns
+ */
+function detectDangerousScriptContent(content) {
+    const lowerContent = content.toLowerCase();
+    // Check for destructive git commands within scripts
+    const dangerousGitPatterns = [
+        /\bgit\s+reset\s+(--hard|--merge|--keep)\b/i,
+        /\bgit\s+clean\s+-f\b/i,
+        /\bgit\s+checkout\s+--\s+\S+/i,
+        /\bgit\s+restore\s+(?!--staged)\s+\S+/i,
+        /\bgit\s+push\s+(-f|--force)\b/i,
+        /\bgit\s+branch\s+-[D]\b/i,
+        /\bgit\s+stash\s+(drop|clear)\b/i,
+    ];
+    for (const pattern of dangerousGitPatterns) {
+        if (pattern.test(lowerContent)) {
+            return {
+                blocked: true,
+                tip: "The script contains a destructive git command. Review the script content.",
+            };
+        }
+    }
+    // Check for dangerous rm -rf patterns (more permissive for scripts, block obvious dangers)
+    const dangerousRmPatterns = [
+        /\brm\s+-rf\s+\/[^\s*]*[a-z]/i, // rm -rf /something (but allow /tmp/* patterns)
+        /\brm\s+-rf\s+\/home/i,
+        /\brm\s+-rf\s+\/usr/i,
+        /\brm\s+-rf\s+\/etc/i,
+        /\brm\s+-rf\s+\/var\s*$/i, // Block /var alone but allow /var/tmp
+        /\brm\s+-rf\s+~(?!\/)/i, // rm -rf ~ but allow ~/tmp
+    ];
+    for (const pattern of dangerousRmPatterns) {
+        if (pattern.test(content)) {
+            return {
+                blocked: true,
+                tip: "The script contains a dangerous rm -rf command.",
+            };
+        }
+    }
+    // Check for format string attacks and other dangerous patterns
+    const dangerousPatterns = [
+        /\brm\s+-rf\s+\$\w+/i, // rm -rf $VAR (variable expansion could be dangerous)
+    ];
+    for (const pattern of dangerousPatterns) {
+        if (pattern.test(content)) {
+            return {
+                blocked: true,
+                tip: "The script contains a potentially dangerous rm command with variable expansion.",
+            };
+        }
+    }
+    return { blocked: false };
+}
+/**
+ * Generate a user-friendly blocked command message
+ */
+export function formatBlockedCommandMessage(result) {
+    return `BLOCKED
+
+Reason: ${result.reason}
+
+Command: ${result.command}
+
+Tip: ${result.tip}`;
+}

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

@@ -0,0 +1 @@
+{"version":3,"file":"dedent.d.ts","sourceRoot":"","sources":["../../source/utils/dedent.ts"],"names":[],"mappings":"AAAA,KAAK,MAAM,GAAG,CAAC,OAAO,EAAE,oBAAoB,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,KAAK,MAAM,CAAC;AAI9E,eAAO,MAAM,MAAM,EAAE,MA+CpB,CAAC"}

package/dist/utils/env-expand.d.ts

@@ -0,0 +1,2 @@
+export declare function expandEnvVars(vars: Record<string, string>): Record<string, string>;
+//# sourceMappingURL=env-expand.d.ts.map

package/dist/utils/env-expand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env-expand.d.ts","sourceRoot":"","sources":["../../source/utils/env-expand.ts"],"names":[],"mappings":"AAEA,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC3B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAUxB"}

package/dist/utils/env-expand.js

@@ -0,0 +1,8 @@
+const ENV_VAR_PATTERN = /\$\{([^}]+)\}|\$([A-Za-z_][A-Za-z0-9_]*)/g;
+export function expandEnvVars(vars) {
+    const result = {};
+    for (const [key, value] of Object.entries(vars)) {
+        result[key] = value.replace(ENV_VAR_PATTERN, (_match, bracedName, plainName) => process.env[bracedName ?? plainName ?? ""] ?? "");
+    }
+    return result;
+}

package/dist/utils/filesystem/path-display.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Converts an absolute path to a relative path for display purposes.
+ * If the path is within the current working directory, returns the relative path.
+ * Otherwise, returns the absolute path unchanged.
+ *
+ * @param absolutePath - The absolute path to convert
+ * @param cwd - The current working directory (defaults to process.cwd())
+ * @returns The display-ready path (relative if within cwd, absolute otherwise)
+ */
+export declare function toDisplayPath(absolutePath: string | undefined | null, cwd?: string): string;
+//# sourceMappingURL=path-display.d.ts.map

package/dist/utils/filesystem/path-display.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-display.d.ts","sourceRoot":"","sources":["../../../source/utils/filesystem/path-display.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,YAAY,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,EACvC,GAAG,GAAE,MAAsB,GAC1B,MAAM,CA0BR"}

package/dist/utils/filesystem/path-display.js

@@ -0,0 +1,32 @@
+import path from "node:path";
+/**
+ * Converts an absolute path to a relative path for display purposes.
+ * If the path is within the current working directory, returns the relative path.
+ * Otherwise, returns the absolute path unchanged.
+ *
+ * @param absolutePath - The absolute path to convert
+ * @param cwd - The current working directory (defaults to process.cwd())
+ * @returns The display-ready path (relative if within cwd, absolute otherwise)
+ */
+export function toDisplayPath(absolutePath, cwd = process.cwd()) {
+    if (!absolutePath) {
+        return ".";
+    }
+    // If path is already relative, return as-is
+    if (!path.isAbsolute(absolutePath)) {
+        return absolutePath;
+    }
+    // Try to get relative path
+    const relativePath = path.relative(cwd, absolutePath);
+    // If relative path starts with '..', it means the path is outside cwd
+    // Return absolute path in that case
+    if (relativePath.startsWith("..")) {
+        return absolutePath;
+    }
+    // If relative path is empty (path equals cwd), return '.'
+    if (relativePath === "") {
+        return ".";
+    }
+    // Return relative path
+    return relativePath;
+}

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

@@ -1,9 +1,9 @@
-import type { ProjectConfig } from "../../config.ts";
+import type { Config } from "../../config/index.ts";
 export declare function joinWorkingDir(userPath: string, workingDir: string): string;
 export declare function isPathWithinAllowedDirs(requestedPath: string, allowedDirs: string[]): boolean;
 export declare function validatePath(requestedPath: string, allowedDirectory: string | string[], options?: {
     requireExistence?: boolean;
     abortSignal?: AbortSignal;
 }): Promise<string>;
-export declare function validateFileNotReadOnly(filePath: string, config: ProjectConfig, workingDir: string): void;
+export declare function validateFileNotReadOnly(filePath: string, config: Config, workingDir: string): void;
 //# sourceMappingURL=security.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"security.d.ts","sourceRoot":"","sources":["../../../source/utils/filesystem/security.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAsCrD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAK3E;AAoCD,wBAAgB,uBAAuB,CACrC,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,MAAM,EAAE,GACpB,OAAO,CAIT;AAGD,wBAAsB,YAAY,CAChC,aAAa,EAAE,MAAM,EACrB,gBAAgB,EAAE,MAAM,GAAG,MAAM,EAAE,EACnC,OAAO,GAAE;IAAE,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,WAAW,CAAA;CAAO,GACtE,OAAO,CAAC,MAAM,CAAC,CAiIjB;AA8BD,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,aAAa,EACrB,UAAU,EAAE,MAAM,GACjB,IAAI,CAIN"}
+{"version":3,"file":"security.d.ts","sourceRoot":"","sources":["../../../source/utils/filesystem/security.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAsCpD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAK3E;AAoCD,wBAAgB,uBAAuB,CACrC,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,MAAM,EAAE,GACpB,OAAO,CAIT;AAsCD,wBAAsB,YAAY,CAChC,aAAa,EAAE,MAAM,EACrB,gBAAgB,EAAE,MAAM,GAAG,MAAM,EAAE,EACnC,OAAO,GAAE;IAAE,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,WAAW,CAAA;CAAO,GACtE,OAAO,CAAC,MAAM,CAAC,CAmGjB;AA8BD,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,GACjB,IAAI,CAIN"}

package/dist/utils/filesystem/security.js

@@ -77,6 +77,33 @@ function isPathWithinBaseDir(requestedPath, baseDir) {
 export function isPathWithinAllowedDirs(requestedPath, allowedDirs) {
     return allowedDirs.some((allowedDir) => isPathWithinBaseDir(requestedPath, allowedDir));
 }
+async function resolveValidAncestor(startDir, isWithinAllowed) {
+    let current = startDir;
+    while (true) {
+        try {
+            const stat = await fs.stat(current);
+            if (!stat.isDirectory()) {
+                throw new Error(`Nearest existing ancestor is not a directory: ${current}`);
+            }
+            const realAncestor = await fs.realpath(current);
+            const normalizedAncestor = normalizePath(realAncestor);
+            if (!isWithinAllowed(normalizedAncestor)) {
+                throw new Error("Access denied - ancestor directory resolves outside allowed directories");
+            }
+            return true;
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.startsWith("Access denied")) {
+                throw err;
+            }
+            const parent = path.dirname(current);
+            if (parent === current) {
+                return false;
+            }
+            current = parent;
+        }
+    }
+}
 // Security utilities
 export async function validatePath(requestedPath, allowedDirectory, options = {}) {
     const { requireExistence = true, abortSignal } = options;
@@ -136,36 +163,7 @@ export async function validatePath(requestedPath, allowedDirectory, options = {}
     catch (_error) {
         // For new files or paths where some directories don't exist yet:
         // Walk up to the nearest existing ancestor directory and validate it.
-        let current = path.dirname(absolute);
-        let foundValidAncestor = false;
-        while (true) {
-            try {
-                const stat = await fs.stat(current);
-                if (!stat.isDirectory()) {
-                    throw new Error(`Nearest existing ancestor is not a directory: ${current}`);
-                }
-                const realAncestor = await fs.realpath(current);
-                const normalizedAncestor = normalizePath(realAncestor);
-                if (!isWithinAllowed(normalizedAncestor)) {
-                    throw new Error("Access denied - ancestor directory resolves outside allowed directories");
-                }
-                // Ancestor is within allowed; allow creation below it.
-                foundValidAncestor = true;
-                break;
-            }
-            catch (err) {
-                // If it's a security denial, rethrow
-                if (err instanceof Error && err.message.startsWith("Access denied")) {
-                    throw err;
-                }
-                // If we reached the filesystem root, break to fallback check
-                const parent = path.dirname(current);
-                if (parent === current) {
-                    break;
-                }
-                current = parent;
-            }
-        }
+        const foundValidAncestor = await resolveValidAncestor(path.dirname(absolute), isWithinAllowed);
         if (!foundValidAncestor) {
             // Rely on intended path check
         }

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

@@ -0,0 +1 @@
+{"version":3,"file":"formatting.d.ts","sourceRoot":"","sources":["../../source/utils/formatting.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,UAAU,GAAG,SAAS,CAAC;AAExD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,UAAU,GACjB,MAAM,CAaR;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,UAAU,GACjB,MAAM,CAWR;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAIrE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,UAAU,GACjB,MAAM,CAWR;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU,GAAI,KAAK,MAAM,KAAG,MACG,CAAC;AAE7C;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,MAAM,KAAG,MASjD,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,cAAc,GAAI,cAAc,MAAM,KAAG,MAuCrD,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,YAAY,GAAI,KAAK,MAAM,KAAG,MAwC1C,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU,GAAI,MAAM,IAAI,KAAG,MASvC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,MAGvD,CAAC"}

package/dist/{formatting.js → utils/formatting.js}

@@ -5,7 +5,7 @@
  * @module formatting
  */
 import path from "node:path";
-import { getCodeblockFromFilePath } from "./utils/filetype-detection.js";
+import { getCodeblockFromFilePath } from "./filetype-detection.js";
 const MD_TRIPLE_QUOTE = "```";
 /**
  * Formats file content with metadata in the specified format.

package/dist/utils/git.d.ts

@@ -18,4 +18,8 @@ export declare function hasUncommittedChanges(): Promise<boolean>;
  * Get the current git branch name
  */
 export declare function getCurrentBranch(): Promise<string | null>;
+/**
+ * Count commits that exist locally but haven't been pushed to the remote branch
+ */
+export declare function getUnpushedCommitsCount(): Promise<number>;
 //# sourceMappingURL=git.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"git.d.ts","sourceRoot":"","sources":["../../source/utils/git.ts"],"names":[],"mappings":"AAIA,wBAAsB,WAAW;;;;GAyDhC;AAED,wBAAsB,YAAY;;;;;GAmCjC;AAED,eAAO,MAAM,cAAc,QAAqB,OAAO,CAAC,OAAO,CAS7D,CAAC;AAEH;;GAEG;AACH,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,OAAO,CAAC,CAY9D;AAED;;GAEG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAkB/D"}
+{"version":3,"file":"git.d.ts","sourceRoot":"","sources":["../../source/utils/git.ts"],"names":[],"mappings":"AAIA,wBAAsB,WAAW;;;;GAyDhC;AAED,wBAAsB,YAAY;;;;;GAmCjC;AAED,eAAO,MAAM,cAAc,QAAqB,OAAO,CAAC,OAAO,CAS7D,CAAC;AAEH;;GAEG;AACH,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,OAAO,CAAC,CAY9D;AAED;;GAEG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAkB/D;AAED;;GAEG;AACH,wBAAsB,uBAAuB,IAAI,OAAO,CAAC,MAAM,CAAC,CAmC/D"}

package/dist/utils/git.js

@@ -133,3 +133,33 @@ export async function getCurrentBranch() {
         return null;
     }
 }
+/**
+ * Count commits that exist locally but haven't been pushed to the remote branch
+ */
+export async function getUnpushedCommitsCount() {
+    try {
+        // First, check if there's a remote configured
+        const remoteResult = await executeCommand(["git", "rev-parse", "--abbrev-ref", "@{u}"], {
+            cwd: process.cwd(),
+            throwOnError: false,
+        });
+        if (remoteResult.code !== 0) {
+            // No upstream configured or no remote
+            return 0;
+        }
+        // Count unpushed commits using git rev-list
+        // @{u}..HEAD gives commits in HEAD but not in upstream (unpushed commits)
+        const result = await executeCommand(["git", "rev-list", "--count", "@{u}..HEAD"], {
+            cwd: process.cwd(),
+            throwOnError: false,
+        });
+        if (result.code !== 0 || !result.stdout.trim()) {
+            return 0;
+        }
+        const count = Number.parseInt(result.stdout.trim(), 10);
+        return Number.isNaN(count) ? 0 : count;
+    }
+    catch {
+        return 0;
+    }
+}

package/dist/utils/glob.d.ts

@@ -4,7 +4,7 @@ type ExpandDirectoriesOption = boolean | readonly string[] | {
     extensions?: readonly string[];
 };
 type FastGlobOptionsWithoutCwd = Omit<FastGlobOptions, "cwd">;
-type Options = {
+export type Options = {
     /**
      * If set to `true`, `glob` will automatically glob directories for you. If you define an `Array` it will only glob files that matches the patterns inside the `Array`. You can also define an `Object` with `files` and `extensions` like in the example below.
      *

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

@@ -1 +1 @@
-{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["../../source/utils/glob.ts"],"names":[],"mappings":"AAIA,OAAW,EAAc,KAAK,OAAO,IAAI,eAAe,EAAE,MAAM,WAAW,CAAC;AAgB5E,KAAK,uBAAuB,GACxB,OAAO,GACP,SAAS,MAAM,EAAE,GACjB;IAAE,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAAC;AAElE,KAAK,yBAAyB,GAAG,IAAI,CAAC,eAAe,EAAE,KAAK,CAAC,CAAC;AAE9D,KAAK,OAAO,GAAG;IACb;;;;;;OAMG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,uBAAuB,CAAC;IAErD;;;;;;OAMG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAE7B;;;;;;;;OAQG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAAC;IAElD;;;;OAIG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,MAAM,CAAC;CAC7B,GAAG,yBAAyB,CAAC;AA6U9B;;;;;;;;GAQG;AACH,eAAO,MAAM,IAAI,8DAtLa,OAAO,sBAoMpC,CAAC"}
+{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["../../source/utils/glob.ts"],"names":[],"mappings":"AAIA,OAAW,EAAc,KAAK,OAAO,IAAI,eAAe,EAAE,MAAM,WAAW,CAAC;AAgB5E,KAAK,uBAAuB,GACxB,OAAO,GACP,SAAS,MAAM,EAAE,GACjB;IAAE,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAAC;AAElE,KAAK,yBAAyB,GAAG,IAAI,CAAC,eAAe,EAAE,KAAK,CAAC,CAAC;AAE9D,MAAM,MAAM,OAAO,GAAG;IACpB;;;;;;OAMG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,uBAAuB,CAAC;IAErD;;;;;;OAMG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAE7B;;;;;;;;OAQG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAAC;IAElD;;;;OAIG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,MAAM,CAAC;CAC7B,GAAG,yBAAyB,CAAC;AA6U9B;;;;;;;;GAQG;AACH,eAAO,MAAM,IAAI,8DAtLa,OAAO,sBAoMpC,CAAC"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../source/utils/logger.ts"],"names":[],"mappings":"AACA,OAAO,IAAI,MAAM,MAAM,CAAC;AAgDxB,eAAO,MAAM,MAAM,6BAIjB,CAAC"}

package/dist/{logger.js → utils/logger.js}

@@ -1,6 +1,6 @@
 import { join } from "node:path";
 import pino from "pino";
-import { config } from "./config.js";
+import { config } from "../config/index.js";
 // Create a lazy logger factory that only initializes when first used
 let loggerInstance = null;
 function createLogger() {

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

@@ -0,0 +1 @@
+{"version":3,"file":"parsing.d.ts","sourceRoot":"","sources":["../../source/utils/parsing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,CAAC,EAAE,MAAM,KAAK,CAAC;AAiBtC,wBAAgB,UAAU,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EAAE,KAAK,EAAE,CAAC,8CAE1D"}

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

@@ -1 +1 @@
-{"version":3,"file":"process.d.ts","sourceRoot":"","sources":["../../source/utils/process.ts"],"names":[],"mappings":"AAOA,UAAU,cAAc;IACtB,2DAA2D;IAC3D,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,yDAAyD;IACzD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,0CAA0C;IAC1C,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,sDAAsD;IACtD,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,2EAA2E;IAC3E,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,mGAAmG;IACnG,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,qDAAqD;IACrD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,UAAU,aAAa;IACrB,uCAAuC;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,sCAAsC;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,qDAAqD;IACrD,IAAI,EAAE,MAAM,CAAC;IACb,qDAAqD;IACrD,MAAM,CAAC,EAAE,MAAM,CAAC,OAAO,CAAC;CACzB;AAED,KAAK,WAAW,GACZ;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,CAAA;CAAE,GACzC;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAGjC,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CA2EpD;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,EACvC,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,aAAa,CAAC,CAqGxB"}
+{"version":3,"file":"process.d.ts","sourceRoot":"","sources":["../../source/utils/process.ts"],"names":[],"mappings":"AAOA,UAAU,cAAc;IACtB,2DAA2D;IAC3D,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,yDAAyD;IACzD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,0CAA0C;IAC1C,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,sDAAsD;IACtD,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,2EAA2E;IAC3E,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,mGAAmG;IACnG,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,qDAAqD;IACrD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,UAAU,aAAa;IACrB,uCAAuC;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,sCAAsC;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,qDAAqD;IACrD,IAAI,EAAE,MAAM,CAAC;IACb,qDAAqD;IACrD,MAAM,CAAC,EAAE,MAAM,CAAC,OAAO,CAAC;CACzB;AAED,KAAK,WAAW,GACZ;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,CAAA;CAAE,GACzC;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAwGjC,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CA8DpD;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,EACvC,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,aAAa,CAAC,CAqGxB"}