@travisennis/acai 0.0.6 → 0.0.8

package/dist/tui/tui.js

@@ -1,7 +1,7 @@
 /**
  * Minimal TUI implementation with differential rendering
  */
-import { getTerminalSize } from "../terminal/formatting.js";
+import { getTerminalSize, isCtrlC, isEscape } from "../terminal/control.js";
 import style from "../terminal/style.js";
 import { visibleWidth } from "./utils.js";
 export { visibleWidth };
@@ -23,11 +23,7 @@ export class Container {
         this.children = [];
     }
     render(width) {
-        const lines = [];
-        for (const child of this.children) {
-            lines.push(...child.render(width));
-        }
-        return lines;
+        return this.children.flatMap((child) => child.render(width));
     }
 }
 /**
@@ -38,7 +34,10 @@ export class TUI extends Container {
     terminal;
     focusedComponent = null;
     renderRequested = false;
+    isRendering = false;
+    renderAgain = false;
     activeModal = null;
+    onCtrlC;
     constructor(terminal) {
         super();
         this.terminal = terminal;
@@ -56,23 +55,32 @@ export class TUI extends Container {
         this.terminal.stop();
     }
     requestRender() {
+        if (this.isRendering) {
+            this.renderAgain = true;
+            return;
+        }
         if (this.renderRequested)
             return;
         this.renderRequested = true;
-        process.nextTick(() => {
+        setImmediate(() => {
             this.renderRequested = false;
             this.doRender();
         });
     }
     handleInput(data) {
         // Handle Ctrl+C globally - exit the application
-        if (data.charCodeAt(0) === 3) {
-            console.log("\nCtrl+C pressed - exiting...");
-            this.stop();
-            process.exit(0);
+        if (isCtrlC(data)) {
+            console.info("\nCtrl+C pressed - exiting...");
+            if (this.onCtrlC) {
+                this.onCtrlC();
+            }
+            else {
+                this.stop();
+                process.exit(0);
+            }
         }
         // Handle Escape key to close modal if one is active
-        if (data === "\x1b" && this.activeModal) {
+        if (isEscape(data) && this.activeModal) {
             this.hideModal();
             return;
         }
@@ -87,42 +95,49 @@ export class TUI extends Container {
         }
     }
     doRender() {
-        const width = this.terminal.columns;
-        // Render all components to get new lines
-        const newLines = this.render(width);
-        // Always do full re-render for simplicity and reliability
-        // This ensures that previous content is properly cleared
-        let buffer = "\x1b[?2026h"; // Begin synchronized output
-        buffer += "\x1b[3J\x1b[2J\x1b[H"; // Clear scrollback, screen, and home
-        for (let i = 0; i < newLines.length; i++) {
-            if (i > 0)
-                buffer += "\r\n";
-            buffer += newLines[i];
+        if (this.isRendering) {
+            this.renderAgain = true;
+            return;
         }
-        // Render modal on top if active
-        if (this.activeModal) {
-            const modalLines = this.activeModal.render(width);
-            // Render backdrop first if modal has backdrop
-            if (this.activeModal.backdrop) {
-                const backdropLine = style.bgRgb(0, 0, 0)(" ".repeat(width));
-                const { columns } = getTerminalSize(); // 24
-                for (let i = 0; i < columns; i++) {
-                    // Cover entire terminal
-                    buffer += `\x1b[${i + 1};1H`;
-                    buffer += backdropLine;
+        this.isRendering = true;
+        try {
+            const width = this.terminal.columns;
+            // Render all components to get new lines
+            const newLines = this.render(width);
+            // Build output buffer using array join (more efficient than string concat)
+            const bufferParts = [
+                "\x1b[?2026h", // Begin synchronized output
+                "\x1b[3J\x1b[2J\x1b[H", // Clear scrollback, screen, and home
+                newLines.join("\r\n"),
+            ];
+            // Render modal on top if active
+            if (this.activeModal) {
+                const modalLines = this.activeModal.render(width);
+                // Render backdrop first if modal has backdrop
+                if (this.activeModal.backdrop) {
+                    const backdropLine = style.bgRgb(0, 0, 0)(" ".repeat(width));
+                    const { rows } = getTerminalSize();
+                    for (let i = 0; i < rows; i++) {
+                        bufferParts.push(`\x1b[${i + 1};1H`, backdropLine);
+                    }
                 }
-            }
-            // Render modal content
-            for (let i = 0; i < modalLines.length; i++) {
-                if (modalLines[i]) {
-                    // Position cursor and overwrite existing content
-                    buffer += `\x1b[${i + 1};1H`;
-                    buffer += modalLines[i];
+                // Render modal content
+                for (let i = 0; i < modalLines.length; i++) {
+                    if (modalLines[i]) {
+                        bufferParts.push(`\x1b[${i + 1};1H`, modalLines[i]);
+                    }
                 }
             }
+            bufferParts.push("\x1b[?2026l"); // End synchronized output
+            this.terminal.write(bufferParts.join(""));
+        }
+        finally {
+            this.isRendering = false;
+            if (this.renderAgain) {
+                this.renderAgain = false;
+                this.requestRender();
+            }
         }
-        buffer += "\x1b[?2026l"; // End synchronized output
-        this.terminal.write(buffer);
     }
     // private positionCursor(
     //   componentCursorPos: [number, number] | null,

package/dist/tui/utils.d.ts

@@ -7,6 +7,11 @@
  * - Tabs (replaced with 3 spaces for consistent width)
  */
 export declare function visibleWidth(str: string): number;
+/**
+ * Truncate text to fit within a maximum visible width, preserving ANSI codes.
+ * Adds ellipsis if truncation occurs.
+ */
+export declare function truncateToWidth(text: string, maxWidth: number, ellipsis?: string): string;
 /**
  * Apply background color to a line, padding to full width.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../source/tui/utils.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAIhD;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAC7B,MAAM,CASR"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../source/tui/utils.ts"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAIhD;AA4BD;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,QAAQ,SAAQ,GACf,MAAM,CA+DR;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAC7B,MAAM,CASR"}

package/dist/tui/utils.js

@@ -1,4 +1,5 @@
-import stringWidth from "string-width";
+import { getSegmenter } from "../terminal/segmenter.js";
+import stringWidth from "../terminal/string-width.js";
 /**
  * Calculate the visible width of a string in terminal columns.
  * This correctly handles:
@@ -12,6 +13,84 @@ export function visibleWidth(str) {
     const normalized = str.replace(/\t/g, "   ");
     return stringWidth(normalized);
 }
+/**
+ * Extract ANSI escape sequences from a string at the given position.
+ */
+function extractAnsiCode(str, pos) {
+    if (pos >= str.length || str[pos] !== "\x1b" || str[pos + 1] !== "[") {
+        return null;
+    }
+    let j = pos + 2;
+    while (j < str.length && str[j] && !/[mGKHJ]/.test(str[j])) {
+        j++;
+    }
+    if (j < str.length) {
+        return {
+            code: str.substring(pos, j + 1),
+            length: j + 1 - pos,
+        };
+    }
+    return null;
+}
+/**
+ * Truncate text to fit within a maximum visible width, preserving ANSI codes.
+ * Adds ellipsis if truncation occurs.
+ */
+export function truncateToWidth(text, maxWidth, ellipsis = "...") {
+    const textVisibleWidth = visibleWidth(text);
+    if (textVisibleWidth <= maxWidth) {
+        return text;
+    }
+    const ellipsisWidth = visibleWidth(ellipsis);
+    const targetWidth = maxWidth - ellipsisWidth;
+    if (targetWidth <= 0) {
+        return ellipsis.substring(0, maxWidth);
+    }
+    // Separate ANSI codes from visible content using grapheme segmentation
+    let i = 0;
+    const segments = [];
+    while (i < text.length) {
+        const ansiResult = extractAnsiCode(text, i);
+        if (ansiResult) {
+            segments.push({ type: "ansi", value: ansiResult.code });
+            i += ansiResult.length;
+        }
+        else {
+            // Find the next ANSI code or end of string
+            let end = i;
+            while (end < text.length) {
+                const nextAnsi = extractAnsiCode(text, end);
+                if (nextAnsi)
+                    break;
+                end++;
+            }
+            // Segment this non-ANSI portion into graphemes
+            const textPortion = text.slice(i, end);
+            for (const seg of getSegmenter().segment(textPortion)) {
+                segments.push({ type: "grapheme", value: seg.segment });
+            }
+            i = end;
+        }
+    }
+    // Build truncated string from segments
+    let result = "";
+    let currentWidth = 0;
+    for (const seg of segments) {
+        if (seg.type === "ansi") {
+            result += seg.value;
+            continue;
+        }
+        const grapheme = seg.value;
+        const graphemeWidth = visibleWidth(grapheme);
+        if (currentWidth + graphemeWidth > targetWidth) {
+            break;
+        }
+        result += grapheme;
+        currentWidth += graphemeWidth;
+    }
+    // Add reset code before ellipsis to prevent styling leaking into it
+    return `${result}\x1b[0m${ellipsis}`;
+}
 /**
  * Apply background color to a line, padding to full width.
  *

package/dist/{tools/bash-utils.d.ts → utils/bash.d.ts}

@@ -1,7 +1,7 @@
-export declare function validatePaths(command: string, allowedDirs: string[], cwd: string, allowedPaths?: string[]): {
+export declare function validatePaths(command: string, allowedDirs: string[], cwd: string): {
     isValid: boolean;
     error?: string;
 };
-export declare const resolveCwd: (cwdInput: string | null | undefined, workingDir: string) => string;
+export declare const resolveCwd: (cwdInput: string | null | undefined, workingDir: string, allowedDirs?: string[]) => string;
 export declare const isMutatingCommand: (rawCommand: string) => boolean;
-//# sourceMappingURL=bash-utils.d.ts.map
+//# sourceMappingURL=bash.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bash.d.ts","sourceRoot":"","sources":["../../source/utils/bash.ts"],"names":[],"mappings":"AAMA,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,CA0EtC;AAED,eAAO,MAAM,UAAU,GACrB,UAAU,MAAM,GAAG,IAAI,GAAG,SAAS,EACnC,YAAY,MAAM,EAClB,cAAc,MAAM,EAAE,KACrB,MAkEF,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,YAAY,MAAM,KAAG,OAmHtD,CAAC"}

package/dist/{tools/bash-utils.js → utils/bash.js}

@@ -1,9 +1,9 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { isPathWithinAllowedDirs } from "./filesystem-utils.js";
+import { isPathWithinAllowedDirs } from "./filesystem/security.js";
 // Validate path arguments to ensure they're within the project
-export function validatePaths(command, allowedDirs, cwd, allowedPaths) {
+export function validatePaths(command, allowedDirs, cwd) {
     // Simple tokenization - split on spaces but respect quotes
     const tokens = [];
     let current = "";
@@ -59,9 +59,7 @@ export function validatePaths(command, allowedDirs, cwd, allowedPaths) {
                 : cleanToken;
             const resolvedPath = path.resolve(cwd, expandedToken);
             // Allow access to explicitly allowed paths
-            const isAllowedPath = allowedPaths?.some((allowedPath) => resolvedPath === path.resolve(allowedPath));
-            if (!isAllowedPath &&
-                !isPathWithinAllowedDirs(resolvedPath, allowedDirs)) {
+            if (!isPathWithinAllowedDirs(resolvedPath, allowedDirs)) {
                 return {
                     isValid: false,
                     error: `Path '${cleanToken}' resolves outside the allowed directories (${resolvedPath}). All paths must be within ${allowedDirs.join(", ")}`,
@@ -72,8 +70,12 @@ export function validatePaths(command, allowedDirs, cwd, allowedPaths) {
     }
     return { isValid: true };
 }
-export const resolveCwd = (cwdInput, workingDir) => {
-    const projectRootAbs = path.resolve(workingDir);
+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)
+    const baseDirForResolution = allowedDirs && allowedDirs.length > 0 ? allowedDirs[0] : workingDir;
+    const projectRootAbs = path.resolve(baseDirForResolution);
     let projectRoot = projectRootAbs;
     try {
         projectRoot = fs.realpathSync(projectRootAbs);
@@ -92,10 +94,19 @@ export const resolveCwd = (cwdInput, workingDir) => {
     catch {
         // If the path doesn't exist entirely, validate intended path
     }
-    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 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}`);
+        }
+    }
+    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}`);
+        }
     }
     // Check existence and that it's a directory
     let stats;

package/dist/utils/{filesystem.d.ts → filesystem/operations.d.ts}

@@ -20,4 +20,4 @@ export declare function isDirectory(filePath: URL | string): Promise<boolean>;
  * @throws Error if directory cannot be cleared or if path is invalid/unsafe
  */
 export declare function clearDirectory(directoryPath: URL | string): Promise<void>;
-//# sourceMappingURL=filesystem.d.ts.map
+//# sourceMappingURL=operations.d.ts.map

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

@@ -0,0 +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"}

package/dist/{tools/filesystem-utils.d.ts → utils/filesystem/security.d.ts}

@@ -1,8 +1,9 @@
+import type { ProjectConfig } from "../../config.ts";
 export declare function joinWorkingDir(userPath: string, workingDir: string): string;
-export declare function isPathWithinBaseDir(requestedPath: string, baseDir: string): boolean;
 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>;
-//# sourceMappingURL=filesystem-utils.d.ts.map
+export declare function validateFileNotReadOnly(filePath: string, config: ProjectConfig, workingDir: string): void;
+//# sourceMappingURL=security.d.ts.map

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

@@ -0,0 +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,CA6HjB;AA8BD,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,aAAa,EACrB,UAAU,EAAE,MAAM,GACjB,IAAI,CAIN"}

package/dist/{tools/filesystem-utils.js → utils/filesystem/security.js}

@@ -1,4 +1,4 @@
-import { realpathSync } from "node:fs";
+import { realpathSync, statSync } from "node:fs";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -6,6 +6,36 @@ import path from "node:path";
 function normalizePath(p) {
     return path.normalize(p);
 }
+// Resolve symlinks for existing ancestors of a path.
+// Walks up the directory tree until an existing directory is found, resolves its real path,
+// and appends the remaining relative path. Permission errors are treated as non-existence.
+function resolveExistingAncestorSync(filePath) {
+    let current = filePath;
+    while (true) {
+        try {
+            const stats = statSync(current);
+            if (stats.isDirectory()) {
+                const realCurrent = realpathSync(current);
+                const remaining = path.relative(current, filePath);
+                return remaining === ""
+                    ? realCurrent
+                    : path.join(realCurrent, remaining);
+            }
+            // If current exists but is not a directory, move up
+        }
+        catch {
+            // current doesn't exist or we lack permission to stat it
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            // Reached root, cannot resolve further
+            break;
+        }
+        current = parent;
+    }
+    // No existing ancestor found, return original path
+    return filePath;
+}
 // Handle path joining with working directory
 export function joinWorkingDir(userPath, workingDir) {
     if (path.isAbsolute(userPath)) {
@@ -20,7 +50,7 @@ function expandHome(filepath) {
     return filepath;
 }
 // Ensure path is within base directory (handles '.', relative paths, and symlinks)
-export function isPathWithinBaseDir(requestedPath, baseDir) {
+function isPathWithinBaseDir(requestedPath, baseDir) {
     const baseAbs = path.resolve(baseDir);
     let baseReal = baseAbs;
     try {
@@ -37,7 +67,8 @@ export function isPathWithinBaseDir(requestedPath, baseDir) {
         target = realpathSync(abs);
     }
     catch {
-        // If target doesn't fully exist, validate against intended path
+        // If target doesn't fully exist, resolve existing ancestors
+        target = resolveExistingAncestorSync(abs);
     }
     const rel = path.relative(baseReal, target);
     return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
@@ -119,7 +150,11 @@ export async function validatePath(requestedPath, allowedDirectory, options = {}
                 foundValidAncestor = true;
                 break;
             }
-            catch (_err) {
+            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) {
@@ -151,3 +186,26 @@ export async function validatePath(requestedPath, allowedDirectory, options = {}
     }
     return validatedPath;
 }
+// Check if a file is read-only based on config
+function isFileReadOnly(filePath, readOnlyFiles, workingDir) {
+    if (readOnlyFiles.length === 0) {
+        return false;
+    }
+    const normalizedFilePath = normalizePath(path.resolve(workingDir, filePath));
+    return readOnlyFiles.some((readOnlyPattern) => {
+        // Handle absolute paths
+        if (path.isAbsolute(readOnlyPattern)) {
+            const normalizedPattern = normalizePath(path.resolve(readOnlyPattern));
+            return normalizedFilePath === normalizedPattern;
+        }
+        // Handle relative paths (relative to working directory)
+        const normalizedRelativePattern = normalizePath(path.resolve(workingDir, readOnlyPattern));
+        return normalizedFilePath === normalizedRelativePattern;
+    });
+}
+// Validate that a file is not read-only before modification
+export function validateFileNotReadOnly(filePath, config, workingDir) {
+    if (isFileReadOnly(filePath, config.readOnlyFiles, workingDir)) {
+        throw new Error(`File is read-only and cannot be modified: ${filePath}`);
+    }
+}

package/dist/utils/funcs.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Identity function for tokens that should not be styled (returns the input string as-is).
+ * See [[Theme]] for an example.
+ */
+export declare const id: <T>(value: T) => T;
+//# sourceMappingURL=funcs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"funcs.d.ts","sourceRoot":"","sources":["../../source/utils/funcs.ts"],"names":[],"mappings":"AACA;;;GAGG;AACH,eAAO,MAAM,EAAE,GAAI,CAAC,EAAE,OAAO,CAAC,KAAG,CAAU,CAAC"}

package/dist/utils/funcs.js

@@ -0,0 +1,6 @@
+//
+/**
+ * Identity function for tokens that should not be styled (returns the input string as-is).
+ * See [[Theme]] for an example.
+ */
+export const id = (value) => value;

package/dist/{tools/git-utils.d.ts → utils/git.d.ts}

@@ -18,4 +18,4 @@ export declare function hasUncommittedChanges(): Promise<boolean>;
  * Get the current git branch name
  */
 export declare function getCurrentBranch(): Promise<string | null>;
-//# sourceMappingURL=git-utils.d.ts.map
+//# sourceMappingURL=git.d.ts.map

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

@@ -0,0 +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"}

package/dist/{tools/git-utils.js → utils/git.js}

@@ -103,9 +103,6 @@ export const inGitDirectory = memoize(async () => {
  * Check if there are uncommitted changes
  */
 export async function hasUncommittedChanges() {
-    if (!(await inGitDirectory())) {
-        return false;
-    }
     try {
         const result = await executeCommand(["git", "status", "--porcelain"], {
             cwd: process.cwd(),
@@ -122,9 +119,6 @@ export async function hasUncommittedChanges() {
  * Get the current git branch name
  */
 export async function getCurrentBranch() {
-    if (!(await inGitDirectory())) {
-        return null;
-    }
     try {
         const result = await executeCommand(["git", "rev-parse", "--abbrev-ref", "HEAD"], {
             cwd: process.cwd(),

package/dist/utils/glob.js

@@ -3,7 +3,7 @@ import { readFile } from "node:fs/promises";
 import path, * as nodePath from "node:path";
 import * as process from "node:process";
 import fg from "fast-glob";
-import { isDirectory, slash, toPath } from "./filesystem.js";
+import { isDirectory, slash, toPath } from "./filesystem/operations.js";
 import { Ignore } from "./ignore.js";
 // Cache for ignore patterns to avoid repeated IO
 const ignoreCache = new Map();

package/dist/utils/yaml.d.ts

@@ -0,0 +1,11 @@
+type YamlValue = string | number | boolean | null | YamlObject | YamlValue[];
+type YamlObject = {
+    [key: string]: YamlValue;
+};
+export declare function parseYaml(input: string): YamlObject;
+export declare function parseFrontMatter(markdown: string): {
+    data: YamlObject;
+    content: string;
+};
+export {};
+//# sourceMappingURL=yaml.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"yaml.d.ts","sourceRoot":"","sources":["../../source/utils/yaml.ts"],"names":[],"mappings":"AAAA,KAAK,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,UAAU,GAAG,SAAS,EAAE,CAAC;AAC7E,KAAK,UAAU,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAC;AAE/C,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CA0DnD;AA2JD,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG;IAClD,IAAI,EAAE,UAAU,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB,CAwBA"}