@travisennis/acai 0.0.5 → 0.0.7

package/dist/execution/index.js

@@ -211,9 +211,18 @@ export class ExecutionEnvironment {
      * Execute a command in the background
      */
     executeCommandInBackground(command, options = {}) {
+        const cwd = options.cwd || this.workingDirectory;
+        // Create the tracked process first
+        const trackedProcess = {
+            pid: -1, // Will be set after spawn
+            kill: () => false, // Will be set after spawn
+            isRunning: true,
+            originalCwd: cwd,
+            startTime: new Date(),
+            command,
+        };
         // Validate command for safety
         this.validateCommand(command);
-        const cwd = options.cwd || this.workingDirectory;
         const env = {
             ...this.environmentVariables,
             ...ttySizeEnv(),
@@ -244,6 +253,21 @@ export class ExecutionEnvironment {
         });
         const pid = childProcess.pid ?? -1;
         let isRunning = true;
+        // Update tracked process with actual PID and kill function
+        trackedProcess.pid = pid;
+        trackedProcess.kill = () => {
+            if (isRunning) {
+                childProcess.kill();
+                isRunning = false;
+                this.backgroundProcesses.delete(pid);
+                // Clean up abort listener
+                if (abortHandler) {
+                    options.abortSignal?.removeEventListener("abort", abortHandler);
+                }
+                return true;
+            }
+            return false;
+        };
         // Set up output handlers
         if (childProcess.stdout) {
             childProcess.stdout.on("data", (data) => {
@@ -292,28 +316,44 @@ export class ExecutionEnvironment {
                 once: true,
             });
         }
-        // Create the process handle
+        // Create the public process handle
         const backgroundProcess = {
             pid,
-            kill: () => {
-                if (isRunning) {
-                    childProcess.kill();
-                    isRunning = false;
-                    this.backgroundProcesses.delete(pid);
-                    // Clean up abort listener
-                    if (abortHandler) {
-                        options.abortSignal?.removeEventListener("abort", abortHandler);
-                    }
-                    return true;
-                }
-                return false;
-            },
+            kill: trackedProcess.kill,
             isRunning: true,
         };
         // Track the process
-        this.backgroundProcesses.set(pid, backgroundProcess);
+        this.backgroundProcesses.set(pid, trackedProcess);
         return backgroundProcess;
     }
+    /**
+     * Get background processes for a specific project directory
+     */
+    getBackgroundProcessesForProject(projectRoot) {
+        const processes = [];
+        for (const process of this.backgroundProcesses.values()) {
+            // Check if process was started in or under the project root
+            if (process.originalCwd.startsWith(projectRoot)) {
+                processes.push(process);
+            }
+        }
+        return processes;
+    }
+    /**
+     * Kill all background processes for a specific project directory
+     */
+    killBackgroundProcessesForProject(projectRoot) {
+        const processes = this.getBackgroundProcessesForProject(projectRoot);
+        logger.info(`Killing ${processes.length} background processes for project: ${projectRoot}`);
+        for (const process of processes) {
+            try {
+                process.kill();
+            }
+            catch (error) {
+                logger.warn(error, `Failed to kill process ${process.pid}`);
+            }
+        }
+    }
     /**
      * Kill all running background processes
      */
@@ -388,13 +428,17 @@ export async function initExecutionEnvironment(config = {}) {
     try {
         const executionEnv = new ExecutionEnvironment(config);
         await executionEnv.initialize();
+        // Set up cleanup for background processes
+        setupProcessCleanup(executionEnv);
         logger.info("Execution environment initialized successfully");
         return executionEnv;
     }
     catch (error) {
         logger.error(error, "Failed to initialize execution environment");
         // Return a minimal execution environment even if initialization failed
-        return new ExecutionEnvironment(config);
+        const executionEnv = new ExecutionEnvironment(config);
+        setupProcessCleanup(executionEnv);
+        return executionEnv;
     }
 }
 // const platformName = process.platform;
@@ -417,16 +461,14 @@ export async function initExecutionEnvironment(config = {}) {
 //   args = ["-c", command];
 // }
 // Set up cleanup on process exit
-export function setupProcessCleanup(executionEnv) {
+function setupProcessCleanup(executionEnv) {
     process.on("exit", () => {
         executionEnv.killAllBackgroundProcesses();
     });
     process.on("SIGINT", () => {
         executionEnv.killAllBackgroundProcesses();
-        process.exit(0);
     });
     process.on("SIGTERM", () => {
         executionEnv.killAllBackgroundProcesses();
-        process.exit(0);
     });
 }

package/dist/formatting.d.ts

@@ -1,6 +1,133 @@
+/**
+ * Formatting utilities for various content types including files, URLs, code blocks, and memory usage.
+ * Provides consistent formatting across different output formats (XML, Markdown, Bracket).
+ *
+ * @module formatting
+ */
+/**
+ * Supported formatting types for content output.
+ */
 export type FormatType = "xml" | "markdown" | "bracket";
+/**
+ * Formats file content with metadata in the specified format.
+ *
+ * @param file - The file path or name
+ * @param content - The file content to format
+ * @param format - The output format type
+ * @returns Formatted file content with metadata
+ * @throws {Error} When an unsupported format is provided
+ *
+ * @example
+ * ```typescript
+ * formatFile("example.ts", "const x = 1;", "markdown")
+ * // Returns: "## File: example.ts\n``` typescript\nconst x = 1;\n```"
+ * ```
+ */
 export declare function formatFile(file: string, content: string, format: FormatType): string;
+/**
+ * Formats URL content with metadata in the specified format.
+ *
+ * @param siteUrl - The URL to format
+ * @param content - The URL content to format
+ * @param format - The output format type
+ * @returns Formatted URL content with metadata
+ * @throws {Error} When an unsupported format is provided
+ *
+ * @example
+ * ```typescript
+ * formatUrl("https://example.com", "<html>...</html>", "xml")
+ * // Returns: "<webpage>\n<url>https://example.com</url>\n<content>\n<html>...</html>\n</content>\n</webpage>"
+ * ```
+ */
 export declare function formatUrl(siteUrl: string, content: string, format: FormatType): string;
+/**
+ * Formats content as a code block with appropriate language identifier.
+ *
+ * @param file - The file path used to determine the code block language
+ * @param content - The code content to format
+ * @returns Formatted code block with language identifier
+ *
+ * @example
+ * ```typescript
+ * formatCodeBlock("example.js", "console.log('hello');")
+ * // Returns: "``` javascript\nconsole.log('hello');\n```"
+ * ```
+ */
 export declare function formatCodeBlock(file: string, content: string): string;
+/**
+ * Formats generic content blocks with a name in the specified format.
+ *
+ * @param content - The block content to format
+ * @param blockName - The name/title of the block
+ * @param format - The output format type
+ * @returns Formatted block content with name
+ * @throws {Error} When an unsupported format is provided
+ *
+ * @example
+ * ```typescript
+ * formatBlock("Some content", "Custom Block", "markdown")
+ * // Returns: "## Custom Block\n```\nSome content\n```"
+ * ```
+ */
 export declare function formatBlock(content: string, blockName: string, format: FormatType): string;
+/**
+ * Capitalizes the first character of a string.
+ *
+ * @param str - The string to capitalize
+ * @returns The string with first character capitalized
+ *
+ * @example
+ * ```typescript
+ * capitalize("hello") // Returns: "Hello"
+ * ```
+ */
+export declare const capitalize: (str: string) => string;
+/**
+ * Formats memory usage in bytes into human-readable units (KB, MB, GB).
+ *
+ * @param bytes - Memory usage in bytes
+ * @returns Formatted memory usage string
+ *
+ * @example
+ * ```typescript
+ * formatMemoryUsage(1024) // Returns: "1.0 KB"
+ * formatMemoryUsage(1048576) // Returns: "1.0 MB"
+ * formatMemoryUsage(1073741824) // Returns: "1.00 GB"
+ * ```
+ */
+export declare const formatMemoryUsage: (bytes: number) => string;
+/**
+ * Formats a duration in milliseconds into a concise, human-readable string.
+ * Omits any time units that are zero.
+ *
+ * @param milliseconds - The duration in milliseconds
+ * @returns A formatted string representing the duration
+ *
+ * @example
+ * ```typescript
+ * formatDuration(3661000) // Returns: "1h 1m 1s"
+ * formatDuration(500) // Returns: "500ms"
+ * formatDuration(1500) // Returns: "1.5s"
+ * ```
+ */
+export declare const formatDuration: (milliseconds: number) => string;
+/**
+ * Formats a number into a compact, human-readable string.
+ * Uses K, M, B, T notation for large numbers while maintaining readability.
+ *
+ * @param num - The number to format
+ * @returns A formatted string representing the number
+ *
+ * @example
+ * ```typescript
+ * formatNumber(1) // Returns: "1"
+ * formatNumber(100) // Returns: "100"
+ * formatNumber(1000) // Returns: "1K"
+ * formatNumber(1100) // Returns: "1.1K"
+ * formatNumber(1234567) // Returns: "1.2M"
+ * formatNumber(1234567890) // Returns: "1.2B"
+ * formatNumber(1234567890123) // Returns: "1.2T"
+ * ```
+ */
+export declare const formatNumber: (num: number) => string;
 //# sourceMappingURL=formatting.d.ts.map

package/dist/formatting.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"formatting.d.ts","sourceRoot":"","sources":["../source/formatting.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,UAAU,GAAG,SAAS,CAAC;AAExD,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,UAAU,GACjB,MAAM,CAaR;AAED,wBAAgB,SAAS,CACvB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,UAAU,GACjB,MAAM,CAWR;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAIrE;AAED,wBAAgB,WAAW,CACzB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,UAAU,GACjB,MAAM,CAWR"}
+{"version":3,"file":"formatting.d.ts","sourceRoot":"","sources":["../source/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"}

package/dist/formatting.js

@@ -1,6 +1,27 @@
+/**
+ * Formatting utilities for various content types including files, URLs, code blocks, and memory usage.
+ * Provides consistent formatting across different output formats (XML, Markdown, Bracket).
+ *
+ * @module formatting
+ */
 import path from "node:path";
 import { getCodeblockFromFilePath } from "./utils/filetype-detection.js";
 const MD_TRIPLE_QUOTE = "```";
+/**
+ * Formats file content with metadata in the specified format.
+ *
+ * @param file - The file path or name
+ * @param content - The file content to format
+ * @param format - The output format type
+ * @returns Formatted file content with metadata
+ * @throws {Error} When an unsupported format is provided
+ *
+ * @example
+ * ```typescript
+ * formatFile("example.ts", "const x = 1;", "markdown")
+ * // Returns: "## File: example.ts\n``` typescript\nconst x = 1;\n```"
+ * ```
+ */
 export function formatFile(file, content, format) {
     const codeBlockName = getCodeblockFromFilePath(file) || path.extname(file).slice(1);
     switch (format) {
@@ -14,6 +35,21 @@ export function formatFile(file, content, format) {
             throw new Error(`Unsupported format: ${format}`);
     }
 }
+/**
+ * Formats URL content with metadata in the specified format.
+ *
+ * @param siteUrl - The URL to format
+ * @param content - The URL content to format
+ * @param format - The output format type
+ * @returns Formatted URL content with metadata
+ * @throws {Error} When an unsupported format is provided
+ *
+ * @example
+ * ```typescript
+ * formatUrl("https://example.com", "<html>...</html>", "xml")
+ * // Returns: "<webpage>\n<url>https://example.com</url>\n<content>\n<html>...</html>\n</content>\n</webpage>"
+ * ```
+ */
 export function formatUrl(siteUrl, content, format) {
     switch (format) {
         case "xml":
@@ -26,10 +62,38 @@ export function formatUrl(siteUrl, content, format) {
             throw new Error(`Unsupported format: ${format}`);
     }
 }
+/**
+ * Formats content as a code block with appropriate language identifier.
+ *
+ * @param file - The file path used to determine the code block language
+ * @param content - The code content to format
+ * @returns Formatted code block with language identifier
+ *
+ * @example
+ * ```typescript
+ * formatCodeBlock("example.js", "console.log('hello');")
+ * // Returns: "``` javascript\nconsole.log('hello');\n```"
+ * ```
+ */
 export function formatCodeBlock(file, content) {
     const codeBlockName = getCodeblockFromFilePath(file) || path.extname(file).slice(1);
     return `${MD_TRIPLE_QUOTE} ${codeBlockName}\n${content}\n${MD_TRIPLE_QUOTE}`;
 }
+/**
+ * Formats generic content blocks with a name in the specified format.
+ *
+ * @param content - The block content to format
+ * @param blockName - The name/title of the block
+ * @param format - The output format type
+ * @returns Formatted block content with name
+ * @throws {Error} When an unsupported format is provided
+ *
+ * @example
+ * ```typescript
+ * formatBlock("Some content", "Custom Block", "markdown")
+ * // Returns: "## Custom Block\n```\nSome content\n```"
+ * ```
+ */
 export function formatBlock(content, blockName, format) {
     switch (format) {
         case "xml":
@@ -42,3 +106,140 @@ export function formatBlock(content, blockName, format) {
             throw new Error(`Unsupported format: ${format}`);
     }
 }
+/**
+ * Capitalizes the first character of a string.
+ *
+ * @param str - The string to capitalize
+ * @returns The string with first character capitalized
+ *
+ * @example
+ * ```typescript
+ * capitalize("hello") // Returns: "Hello"
+ * ```
+ */
+export const capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+/**
+ * Formats memory usage in bytes into human-readable units (KB, MB, GB).
+ *
+ * @param bytes - Memory usage in bytes
+ * @returns Formatted memory usage string
+ *
+ * @example
+ * ```typescript
+ * formatMemoryUsage(1024) // Returns: "1.0 KB"
+ * formatMemoryUsage(1048576) // Returns: "1.0 MB"
+ * formatMemoryUsage(1073741824) // Returns: "1.00 GB"
+ * ```
+ */
+export const formatMemoryUsage = (bytes) => {
+    const gb = bytes / (1024 * 1024 * 1024);
+    if (bytes < 1024 * 1024) {
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    }
+    if (bytes < 1024 * 1024 * 1024) {
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    }
+    return `${gb.toFixed(2)} GB`;
+};
+/**
+ * Formats a duration in milliseconds into a concise, human-readable string.
+ * Omits any time units that are zero.
+ *
+ * @param milliseconds - The duration in milliseconds
+ * @returns A formatted string representing the duration
+ *
+ * @example
+ * ```typescript
+ * formatDuration(3661000) // Returns: "1h 1m 1s"
+ * formatDuration(500) // Returns: "500ms"
+ * formatDuration(1500) // Returns: "1.5s"
+ * ```
+ */
+export const formatDuration = (milliseconds) => {
+    if (milliseconds <= 0) {
+        return "0s";
+    }
+    if (milliseconds < 1000) {
+        return `${Math.round(milliseconds)}ms`;
+    }
+    const totalSeconds = milliseconds / 1000;
+    if (totalSeconds < 60) {
+        return `${totalSeconds.toFixed(1)}s`;
+    }
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = Math.floor(totalSeconds % 60);
+    const parts = [];
+    if (hours > 0) {
+        parts.push(`${hours}h`);
+    }
+    if (minutes > 0) {
+        parts.push(`${minutes}m`);
+    }
+    if (seconds > 0) {
+        parts.push(`${seconds}s`);
+    }
+    // If all parts are zero (e.g., exactly 1 hour), return the largest unit.
+    if (parts.length === 0) {
+        if (hours > 0)
+            return `${hours}h`;
+        if (minutes > 0)
+            return `${minutes}m`;
+        return `${seconds}s`;
+    }
+    return parts.join(" ");
+};
+/**
+ * Formats a number into a compact, human-readable string.
+ * Uses K, M, B, T notation for large numbers while maintaining readability.
+ *
+ * @param num - The number to format
+ * @returns A formatted string representing the number
+ *
+ * @example
+ * ```typescript
+ * formatNumber(1) // Returns: "1"
+ * formatNumber(100) // Returns: "100"
+ * formatNumber(1000) // Returns: "1K"
+ * formatNumber(1100) // Returns: "1.1K"
+ * formatNumber(1234567) // Returns: "1.2M"
+ * formatNumber(1234567890) // Returns: "1.2B"
+ * formatNumber(1234567890123) // Returns: "1.2T"
+ * ```
+ */
+export const formatNumber = (num) => {
+    if (num < 1000) {
+        return num.toString();
+    }
+    const units = ["", "K", "M", "B", "T"];
+    // Calculate unit index based on number of digits
+    const numDigits = Math.floor(Math.log10(num)) + 1;
+    let unitIndex = Math.min(Math.floor((numDigits - 1) / 3), units.length - 1);
+    let unit = units[unitIndex] || "";
+    // Calculate scaled value
+    let scaled = num / 1000 ** unitIndex;
+    // Check if we need to move to the next unit (e.g., 999.999K -> 1M)
+    if (Math.round(scaled) >= 1000 && unitIndex < units.length - 1) {
+        unitIndex++;
+        unit = units[unitIndex] || "";
+        scaled = num / 1000 ** unitIndex;
+    }
+    // Determine decimal places based on the value
+    if (scaled < 10) {
+        // For values under 10, show one decimal place unless it's a whole number
+        // Also handle the case where rounding would give a whole number
+        const rounded = Math.round(scaled * 10) / 10;
+        return rounded % 1 === 0
+            ? `${Math.round(rounded)}${unit}`
+            : `${rounded.toFixed(1)}${unit}`;
+    }
+    if (scaled < 100) {
+        // For values between 10-100, show one decimal place unless it's a whole number
+        const rounded = Math.round(scaled * 10) / 10;
+        return rounded % 1 === 0
+            ? `${Math.round(rounded)}${unit}`
+            : `${rounded.toFixed(1)}${unit}`;
+    }
+    // For values 100+, round to nearest whole number
+    return `${Math.round(scaled)}${unit}`;
+};

package/dist/index.d.ts

@@ -1,11 +1,16 @@
 #!/usr/bin/env node
+export interface WorkspaceContext {
+    primaryDir: string;
+    allowedDirs: string[];
+}
+export declare function createWorkspaceContext(addDirArgs?: string[]): WorkspaceContext;
 declare const flags: {
     model?: string | undefined;
     prompt?: string | undefined;
-    oneshot: boolean;
     continue: boolean;
     resume: boolean;
-    autoAcceptAll: boolean;
+    "add-dir"?: string[] | undefined;
+    "no-skills": boolean;
     help?: boolean | undefined;
     version?: boolean | undefined;
 };

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../source/index.ts"],"names":[],"mappings":";AAwDA,QAAA,MAAM,KAAK;;;;;;;;;CAAgB,CAAC;AAG5B;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAE9C;AAED,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../source/index.ts"],"names":[],"mappings":";AAkCA,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AAGD,wBAAgB,sBAAsB,CACpC,UAAU,GAAE,MAAM,EAAO,GACxB,gBAAgB,CAmBlB;AAuCD,QAAA,MAAM,KAAK;;;;;;;;;CAAgB,CAAC;AAM5B;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAE9C;AAED,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC"}