@travisennis/acai 0.0.9 → 0.0.11

package/dist/execution/index.js

@@ -5,7 +5,7 @@
  * in a controlled environment with proper error handling.
  */
 import { exec, spawn } from "node:child_process";
-import { logger } from "../logger.js";
+import { logger } from "../utils/logger.js";
 /**
  * List of dangerous commands that shouldn't be executed
  */
@@ -44,6 +44,37 @@ function ttySizeEnv() {
     }
     return env;
 }
+/**
+ * Factory function for creating abort handlers.
+ * Defined at module level to avoid capturing closure scope,
+ * preventing memory leaks when AbortSignal is long-lived.
+ */
+function createAbortHandler(childProc, cmd, start, settleFn, shouldThrow) {
+    return function abortHandler() {
+        childProc.kill("SIGTERM");
+        const error = new Error("Command execution aborted");
+        const duration = Date.now() - start;
+        settleFn({
+            output: "",
+            exitCode: 1,
+            error,
+            command: cmd,
+            duration,
+        }, shouldThrow, error);
+    };
+}
+/**
+ * Factory function for creating background process abort handlers.
+ * Defined at module level to avoid capturing closure scope.
+ * Note: Process cleanup from backgroundProcesses map is handled by the exit handler.
+ */
+function createBackgroundAbortHandler(childProc, getRunningState) {
+    return function abortHandler() {
+        if (getRunningState()) {
+            childProc.kill("SIGTERM");
+        }
+    };
+}
 export class ExecutionEnvironment {
     config;
     backgroundProcesses = new Map();
@@ -148,62 +179,58 @@ export class ExecutionEnvironment {
                     resolve(result);
                 }
             };
-            const childProcess = exec(command, {
-                cwd,
-                env,
-                timeout,
-                maxBuffer,
-                shell,
-                windowsHide: true,
-                encoding: "utf8",
-            }, (error, stdout, stderr) => {
+            // Extract callback handlers to reduce cognitive complexity
+            const handleExecError = (error, output, duration) => {
+                const exitCode = error.code ?? 1;
+                logger.error({
+                    error: error.message,
+                    exitCode,
+                    duration,
+                }, `Command execution failed: ${command}`);
+                settle({
+                    output: preserveOutputOnError ? output : "",
+                    exitCode,
+                    error,
+                    command,
+                    duration,
+                }, throwOnError, error);
+            };
+            const handleExecSuccess = (output, duration) => {
+                logger.debug({
+                    duration,
+                    outputLength: output.length,
+                }, `Command executed successfully: ${command}`);
+                settle({
+                    output,
+                    exitCode: 0,
+                    command,
+                    duration,
+                }, false);
+            };
+            const handleExecCallback = (error, stdout, stderr) => {
                 const duration = Date.now() - startTime;
-                // Combine stdout and stderr if requested
                 const output = captureStderr
                     ? `${stdout}${stderr ? stderr : ""}`
                     : stdout;
                 if (error) {
-                    const exitCode = error.code ?? 1;
-                    logger.error({
-                        error: error.message,
-                        exitCode,
-                        duration,
-                    }, `Command execution failed: ${command}`);
-                    settle({
-                        output: preserveOutputOnError ? output : "",
-                        exitCode,
-                        error,
-                        command,
-                        duration,
-                    }, throwOnError, error);
+                    handleExecError(error, output, duration);
                 }
                 else {
-                    logger.debug({
-                        duration,
-                        outputLength: output.length,
-                    }, `Command executed successfully: ${command}`);
-                    settle({
-                        output,
-                        exitCode: 0,
-                        command,
-                        duration,
-                    }, false);
+                    handleExecSuccess(output, duration);
                 }
-            });
+            };
+            const childProcess = exec(command, {
+                cwd,
+                env,
+                timeout,
+                maxBuffer,
+                shell,
+                windowsHide: true,
+                encoding: "utf8",
+            }, handleExecCallback);
             // Handle abort signal
             if (options.abortSignal) {
-                abortHandler = () => {
-                    logger.warn({ command, pid: childProcess.pid }, "Command execution aborted");
-                    childProcess.kill("SIGTERM");
-                    const error = new Error("Command execution aborted");
-                    settle({
-                        output: "",
-                        exitCode: 1,
-                        error,
-                        command,
-                        duration: Date.now() - startTime,
-                    }, throwOnError, error);
-                };
+                abortHandler = createAbortHandler(childProcess, command, startTime, settle, throwOnError);
                 options.abortSignal.addEventListener("abort", abortHandler, {
                     once: true,
                 });
@@ -314,14 +341,7 @@ export class ExecutionEnvironment {
         // Handle abort signal for background process
         let abortHandler;
         if (options.abortSignal) {
-            abortHandler = () => {
-                logger.warn({ command, pid }, "Background command execution aborted");
-                if (isRunning) {
-                    childProcess.kill("SIGTERM");
-                    isRunning = false;
-                    this.backgroundProcesses.delete(pid);
-                }
-            };
+            abortHandler = createBackgroundAbortHandler(childProcess, () => isRunning);
             options.abortSignal.addEventListener("abort", abortHandler, {
                 once: true,
             });

package/dist/index.d.ts

@@ -11,6 +11,7 @@ declare const flags: {
     resume: boolean;
     "add-dir"?: string[] | undefined;
     "no-skills": boolean;
+    "no-session": 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":";AAgCA,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;AAmDD,QAAA,MAAM,KAAK;;;;;;;;;CAAyB,CAAC;AAMrC;;;;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":";AA6BA,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,CAsBlB;AAoDD,QAAA,MAAM,KAAK;;;;;;;;;;CAAyB,CAAC;AAMrC;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAE9C;AAED,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC"}

package/dist/index.js

@@ -6,32 +6,36 @@ import { parseArgs } from "node:util";
 import { asyncTry, isFailure, syncTry } from "@travisennis/stdlib/try";
 import { isDefined } from "@travisennis/stdlib/typeguards";
 import { Agent } from "./agent/index.js";
-import { Cli } from "./cli.js";
+import { Cli } from "./cli/index.js";
+import { readStdinWithLimits } from "./cli/stdin.js";
 import { CommandManager } from "./commands/manager.js";
-import { config, } from "./config.js";
-import { logger } from "./logger.js";
-import { PromptError, processPrompt } from "./mentions.js";
+import { config } from "./config/index.js";
 import { ModelManager } from "./models/manager.js";
 import { isSupportedModel } from "./models/providers.js";
 import { PromptManager } from "./prompts/manager.js";
-import { systemPrompt } from "./prompts.js";
-import { NewRepl } from "./repl-new.js";
+import { processPrompt } from "./prompts/mentions.js";
+import { systemPrompt } from "./prompts/system-prompt.js";
+import { Repl } from "./repl/index.js";
 import { SessionManager } from "./sessions/manager.js";
-import { readStdinWithLimits } from "./stdin.js";
+import { writeExitSummary } from "./sessions/summary.js";
 import { setTerminalTitle } from "./terminal/control.js";
 import { select } from "./terminal/select-prompt.js";
 import { TokenCounter } from "./tokens/counter.js";
 import { TokenTracker } from "./tokens/tracker.js";
 import { initTools } from "./tools/index.js";
-import { getPackageVersion } from "./version.js";
+import { logger } from "./utils/logger.js";
+import { getPackageVersion } from "./utils/version.js";
 // Create workspace context from CLI arguments
 export function createWorkspaceContext(addDirArgs = []) {
     const primaryDir = process.cwd();
     mkdirSync("/tmp/acai", { recursive: true });
     const allowedDirs = [
         primaryDir,
+        "/tmp",
         "/tmp/acai",
+        "/var/folders",
         path.join(os.homedir(), ".acai"),
+        path.join(os.homedir(), ".agents"),
         ...addDirArgs,
     ];
     // Remove duplicates while preserving order
@@ -52,7 +56,7 @@ Options
   --resume           Resume a specific session by ID, or most recent if no ID given
   --add-dir          Add additional working directory (can be used multiple times)
   --no-skills        Disable skills discovery and loading
-
+  --no-session       Don't save session to disk
 
   --help, -h         Show help
   --version, -v      Show version
@@ -73,6 +77,7 @@ const parsed = syncTry(() => parseArgs({
         resume: { type: "boolean", default: false },
         "add-dir": { type: "string", multiple: true },
         "no-skills": { type: "boolean", default: false },
+        "no-session": { type: "boolean", default: false },
         help: { type: "boolean", short: "h" },
         version: { type: "boolean", short: "v" },
     },
@@ -96,46 +101,34 @@ export function handleError(error) {
     logger.error({ error: error }, error.message);
 }
 // Configuration constants
-const DEFAULT_HISTORY_LIMIT = 10;
-const CONTINUE_HISTORY_LIMIT = 1;
+const DEFAULT_HISTORY_LIMIT = 20; // the amount of sessions to retrieve from session history
 // Helper functions for main()
 async function initializeAppState(appConfig, initialPromptInput, stdinContent, hasContinueOrResume, resumeSessionId) {
     const appDir = config.app;
     // Parallelize independent async operations
-    const [messageHistoryDir, modelManager] = await Promise.all([
-        appDir.ensurePath("message-history"),
+    const [sessionsDir, modelManager] = await Promise.all([
+        appDir.ensurePath("sessions"),
         initializeModelManager(appDir),
     ]);
     // Initialize synchronous components
     const tokenTracker = new TokenTracker();
     const tokenCounter = new TokenCounter();
     // Initialize dependent components
-    const sessionManager = await initializeSessionManager(messageHistoryDir, modelManager, tokenTracker);
+    const sessionManager = await initializeSessionManager(sessionsDir, modelManager, tokenTracker);
     // Handle conversation history loading
-    await handleConversationHistory(sessionManager, messageHistoryDir, hasContinueOrResume, resumeSessionId);
+    await handleConversationHistory(sessionManager, sessionsDir, hasContinueOrResume, resumeSessionId);
     // Setup prompt manager
     const promptManager = new PromptManager(tokenCounter);
     if (!hasContinueOrResume && isDefined(initialPromptInput)) {
-        try {
-            const modelConfig = modelManager.getModelMetadata("repl");
-            const processedPrompt = await processPrompt(initialPromptInput, {
-                baseDir: process.cwd(),
-                model: modelConfig,
-            });
-            for (const context of processedPrompt.context) {
-                promptManager.addContext(context);
-            }
-            promptManager.set(processedPrompt.message);
-        }
-        catch (error) {
-            if (error instanceof PromptError) {
-                logger.error(`Prompt mention error: ${error.message}`);
-                promptManager.set(initialPromptInput);
-            }
-            else {
-                throw new Error("Failed to process prompt.", { cause: error });
-            }
+        const modelConfig = modelManager.getModelMetadata("repl");
+        const processedPrompt = await processPrompt(initialPromptInput, {
+            baseDir: process.cwd(),
+            model: modelConfig,
+        });
+        for (const context of processedPrompt.context) {
+            promptManager.addContext(context);
         }
+        promptManager.set(processedPrompt.message);
     }
     if (stdinContent && stdinContent.trim().length > 0) {
         if (isDefined(initialPromptInput)) {
@@ -228,41 +221,42 @@ async function determineInitialPrompt() {
 async function initializeModelManager(appDir) {
     const chosenModel = isSupportedModel(flags.model)
         ? flags.model
-        : "opencode:minimax-m2-1";
+        : "opencode-go:kimi-k2-5";
+    const projectConfig = await config.getConfig();
+    const devtoolsEnabled = projectConfig.devtools?.enabled ?? false;
     const modelManager = new ModelManager({
         stateDir: await appDir.ensurePath("audit"),
+        devtoolsEnabled,
     });
     modelManager.setModel("repl", chosenModel);
     modelManager.setModel("cli", chosenModel);
     modelManager.setModel("title-conversation", chosenModel);
     modelManager.setModel("conversation-summarizer", chosenModel);
-    modelManager.setModel("tool-repair", chosenModel);
+    modelManager.setModel("tool-repair", "openai:gpt-5.1-codex-mini");
     modelManager.setModel("conversation-analyzer", chosenModel);
     modelManager.setModel("init-project", chosenModel);
-    modelManager.setModel("task-agent", chosenModel);
     modelManager.setModel("handoff-agent", chosenModel);
-    modelManager.setModel("edit-fix", chosenModel);
     return modelManager;
 }
-async function initializeSessionManager(messageHistoryDir, modelManager, tokenTracker) {
-    const messageHistory = new SessionManager({
-        stateDir: messageHistoryDir,
+async function initializeSessionManager(sessionsDir, modelManager, tokenTracker) {
+    const sessionManager = new SessionManager({
+        stateDir: sessionsDir,
         modelManager,
         tokenTracker,
     });
-    messageHistory.on("update-title", (title) => setTerminalTitle(title));
+    sessionManager.on("update-title", (title) => setTerminalTitle(title));
     // Listen for model changes and update session manager when repl model changes
     modelManager.on("set-model", (app, _model) => {
         if (app === "repl") {
             const modelId = modelManager.getModel("repl").modelId;
-            messageHistory.setModelId(modelId);
+            sessionManager.setModelId(modelId);
         }
     });
-    return messageHistory;
+    return sessionManager;
 }
-async function handleConversationHistory(messageHistory, messageHistoryDir, _hasContinueOrResume, resumeSessionId) {
+async function handleConversationHistory(sessionManager, sessionsDir, _hasContinueOrResume, resumeSessionId) {
     if (flags.continue === true) {
-        const histories = await SessionManager.load(messageHistoryDir, DEFAULT_HISTORY_LIMIT);
+        const histories = await SessionManager.load(sessionsDir, DEFAULT_HISTORY_LIMIT);
         if (histories.length > 0) {
             try {
                 const choice = await select({
@@ -275,7 +269,7 @@ async function handleConversationHistory(messageHistory, messageHistoryDir, _has
                 });
                 const selectedHistory = histories.at(choice);
                 if (selectedHistory) {
-                    messageHistory.restore(selectedHistory);
+                    sessionManager.restore(selectedHistory);
                     logger.info(`Resuming conversation: ${selectedHistory.title}`);
                     setTerminalTitle(selectedHistory.title || `acai: ${process.cwd()}`);
                 }
@@ -300,10 +294,10 @@ async function handleConversationHistory(messageHistory, messageHistoryDir, _has
     }
     else if (flags.resume === true) {
         if (resumeSessionId) {
-            const histories = await SessionManager.load(messageHistoryDir, DEFAULT_HISTORY_LIMIT);
+            const histories = await SessionManager.load(sessionsDir, DEFAULT_HISTORY_LIMIT);
             const targetHistory = histories.find((h) => h.sessionId === resumeSessionId);
             if (targetHistory) {
-                messageHistory.restore(targetHistory);
+                sessionManager.restore(targetHistory);
                 logger.info(`Resuming conversation: ${targetHistory.title}`);
                 setTerminalTitle(targetHistory.title || `acai: ${process.cwd()}`);
             }
@@ -313,10 +307,10 @@ async function handleConversationHistory(messageHistory, messageHistoryDir, _has
             }
         }
         else {
-            const histories = await SessionManager.load(messageHistoryDir, CONTINUE_HISTORY_LIMIT);
+            const histories = await SessionManager.load(sessionsDir, 1); // read the most recent session
             const latestHistory = histories.at(0);
             if (latestHistory) {
-                messageHistory.restore(latestHistory);
+                sessionManager.restore(latestHistory);
                 console.info(`Resuming conversation: ${latestHistory.title}`);
                 setTerminalTitle(latestHistory.title || `acai: ${process.cwd()}`);
             }
@@ -326,133 +320,134 @@ async function handleConversationHistory(messageHistory, messageHistoryDir, _has
         }
     }
 }
-async function runCliMode(state) {
-    const skillsEnabled = !flags["no-skills"] && (await config.getSkillsEnabled());
+async function runCliMode(state, noSession) {
     const cliProcess = new Cli({
         promptManager: state.promptManager,
-        messageHistory: state.sessionManager,
+        sessionManager: state.sessionManager,
         modelManager: state.modelManager,
         tokenTracker: state.tokenTracker,
         tokenCounter: state.tokenCounter,
         workspace,
-        skillsEnabled,
+        noSession,
     });
     (await asyncTry(cliProcess.run())).recover(handleError);
 }
-async function runReplMode(state, stdinWasPiped) {
-    // Initialize tools before creating REPL (needed for session reload reconstruction)
-    const tools = await initTools({
-        workspace,
-    });
-    const agent = new Agent({
-        sessionManager: state.sessionManager,
-        modelManager: state.modelManager,
-        tokenTracker: state.tokenTracker,
-    });
-    // When stdin was piped, use /dev/tty for interactive input instead of process.stdin
-    const repl = new NewRepl({
-        agent,
-        promptManager: state.promptManager,
-        config: state.appConfig,
-        messageHistory: state.sessionManager,
-        modelManager: state.modelManager,
-        tokenTracker: state.tokenTracker,
-        commands: state.commands,
-        tokenCounter: state.tokenCounter,
-        promptHistory: state.promptHistory,
-        workspace,
-        tools,
-        terminalOptions: { useTty: stdinWasPiped },
-    });
-    await repl.init();
-    // Reconstruct session display if there are existing messages
-    if (!state.sessionManager.isEmpty()) {
-        await repl.rerender();
-    }
-    state.sessionManager.on("clear-history", () => {
+function setupReplEventHandlers(repl, agent, sessionManager, noSession) {
+    sessionManager.on("clear-history", async () => {
         logger.info("Resetting agent state.");
         agent.resetState();
+        agent.setConfig(await config.getConfig());
         void repl.rerender();
     });
-    // Set interrupt callback
     repl.setInterruptCallback(async () => {
-        try {
-            await state.sessionManager.save();
-        }
-        catch (error) {
-            // Log but don't throw - we still want to abort the agent
-            logger.warn({ error }, "Failed to save message history on interrupt");
+        if (!noSession) {
+            try {
+                await sessionManager.save();
+            }
+            catch (error) {
+                logger.warn({ error }, "Failed to save message history on interrupt");
+            }
         }
         agent.abort();
     });
-    // Set exit callback
-    repl.setExitCallback((sessionId) => {
-        if (!state.sessionManager.isEmpty()) {
-            console.info(`\nTo resume this session call acai --resume ${sessionId}`);
+    repl.setExitCallback(async (_sessionId) => {
+        if (!sessionManager.isEmpty()) {
+            await repl.triggerRuleGeneration();
+            writeExitSummary(sessionManager, noSession);
         }
     });
-    // Auto-process pending prompt from stdin
-    if (state.promptManager.isPending()) {
-        const projectConfig = await config.getConfig();
-        const activeTools = projectConfig.tools.activeTools;
-        const skillsEnabled = !flags["no-skills"] && (projectConfig.skills?.enabled ?? true);
-        try {
-            // Get the prompt text before it gets cleared by getUserMessage()
-            const promptText = state.promptManager.get();
-            // Get the user message (includes context if any) and add to history
-            const userMessage = state.promptManager.getUserMessage();
-            state.sessionManager.appendUserMessage(userMessage);
-            const systemPromptResult = await systemPrompt({
-                activeTools,
-                allowedDirs: workspace.allowedDirs,
-                skillsEnabled,
-            });
-            const results = agent.run({
-                systemPrompt: systemPromptResult.prompt,
-                input: promptText,
-                tools,
-                activeTools,
-                abortSignal: agent.abortSignal,
-            });
-            for await (const result of results) {
-                await repl.handle(result, agent.state);
-            }
-            await state.sessionManager.save();
+}
+async function handleStdinPrompt(state, agent, repl, tools, activeTools, systemPromptResult, noSession) {
+    if (!state.promptManager.isPending()) {
+        return false;
+    }
+    try {
+        const promptText = state.promptManager.get();
+        const userMessage = state.promptManager.getUserMessage();
+        state.sessionManager.appendUserMessage(userMessage);
+        const results = agent.run({
+            systemPrompt: systemPromptResult.prompt,
+            input: promptText,
+            tools,
+            activeTools,
+            abortSignal: agent.abortSignal,
+            maxIterations: state.appConfig.loop.maxIterations,
+        });
+        for await (const result of results) {
+            await repl.handle(result, agent.state);
         }
-        catch (_error) {
-            // Error displayed in the TUI
+        if (!noSession) {
+            await state.sessionManager.save();
         }
+        return true;
     }
-    // Interactive loop
+    catch {
+        return false;
+    }
+}
+async function runInteractiveLoop(repl, agent, tools, activeTools, systemPromptResult, noSession, sessionManager, maxIterations) {
     while (true) {
         const userInput = await repl.getUserInput();
-        const projectConfig = await config.getConfig();
-        const activeTools = projectConfig.tools.activeTools;
-        const skillsEnabled = !flags["no-skills"] && (projectConfig.skills?.enabled ?? true);
         try {
-            const systemPromptResult = await systemPrompt({
-                activeTools,
-                allowedDirs: workspace.allowedDirs,
-                skillsEnabled,
-            });
             const results = agent.run({
                 systemPrompt: systemPromptResult.prompt,
                 input: userInput,
                 tools,
                 activeTools,
                 abortSignal: agent.abortSignal,
+                maxIterations,
             });
             for await (const result of results) {
                 await repl.handle(result, agent.state);
             }
-            await state.sessionManager.save();
+            if (!noSession) {
+                await sessionManager.save();
+            }
         }
-        catch (_error) {
-            // Display error in the TUI by adding an error message to the chat
-            // repl.showError((error as Error).message || "Unknown error occurred");
+        catch {
+            // Error displayed in the TUI
         }
     }
 }
+async function runReplMode(state, stdinWasPiped, noSession) {
+    const tools = await initTools({ workspace });
+    const agent = new Agent({
+        config: state.appConfig,
+        sessionManager: state.sessionManager,
+        modelManager: state.modelManager,
+        tokenTracker: state.tokenTracker,
+    });
+    const repl = new Repl({
+        agent,
+        promptManager: state.promptManager,
+        configManager: config,
+        sessionManager: state.sessionManager,
+        modelManager: state.modelManager,
+        tokenTracker: state.tokenTracker,
+        commands: state.commands,
+        tokenCounter: state.tokenCounter,
+        promptHistory: state.promptHistory,
+        workspace,
+        tools,
+        terminalOptions: { useTty: stdinWasPiped },
+        noSession,
+    });
+    await repl.init();
+    if (!state.sessionManager.isEmpty()) {
+        await repl.rerender();
+    }
+    setupReplEventHandlers(repl, agent, state.sessionManager, noSession);
+    const activeTools = state.appConfig.tools.activeTools;
+    const skillsEnabled = !flags["no-skills"] && (state.appConfig.skills?.enabled ?? true);
+    const systemPromptResult = await systemPrompt({
+        activeTools,
+        allowedDirs: workspace.allowedDirs,
+        logsPath: state.appConfig.logs?.path,
+        skillsEnabled,
+    });
+    await handleStdinPrompt(state, agent, repl, tools, activeTools, systemPromptResult, noSession);
+    await runInteractiveLoop(repl, agent, tools, activeTools, systemPromptResult, noSession, state.sessionManager, state.appConfig.loop.maxIterations);
+}
 async function main() {
     try {
         const appConfig = await config.ensureDefaultConfig("acai");
@@ -467,14 +462,26 @@ async function main() {
         const { initialPromptInput, stdinContent, hasContinueOrResume, resumeSessionId, } = await determineInitialPrompt();
         // Initialize application state
         const state = await initializeAppState(appConfig, initialPromptInput, stdinContent, hasContinueOrResume, resumeSessionId);
+        // Add logs directory to allowed directories if configured
+        const logsPath = (await config.getConfig()).logs?.path;
+        if (logsPath) {
+            // Expand ~ to home directory before resolving
+            const expandedLogsPath = logsPath.startsWith("~/") || logsPath === "~"
+                ? path.join(os.homedir(), logsPath.slice(1))
+                : logsPath;
+            const logsDir = path.dirname(path.resolve(expandedLogsPath));
+            if (!workspace.allowedDirs.includes(logsDir)) {
+                workspace.allowedDirs.push(logsDir);
+            }
+        }
         // Set terminal title after all validation is complete
         setTerminalTitle(`acai: ${workspace.primaryDir}`);
         // Handle CLI mode if initial prompt provided
         if (isDefined(initialPromptInput)) {
-            return await runCliMode(state);
+            return await runCliMode(state, flags["no-session"] === true);
         }
         // Setup REPL mode
-        return await runReplMode(state, stdinContent !== null);
+        return await runReplMode(state, stdinContent !== null, flags["no-session"] === true);
     }
     catch (error) {
         handleError(error);

package/dist/middleware/cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../source/middleware/cache.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,yBAAyB,EAE1B,MAAM,kBAAkB,CAAC;AA+F1B,eAAO,MAAM,eAAe,EAAE,yBAqF7B,CAAC"}
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../source/middleware/cache.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,yBAAyB,EAE1B,MAAM,kBAAkB,CAAC;AAyE1B,eAAO,MAAM,eAAe,EAAE,yBA+E7B,CAAC"}