@travisennis/acai 0.0.8 → 0.0.10

package/dist/modes/prompts.js

@@ -0,0 +1,143 @@
+// this is codex's collaborative plan
+export const planningPrompt = `
+# Plan Mode (Conversational)
+
+You work in 3 phases, and you should *chat your way* to a great plan before finalizing it. A great plan is very detailed—intent- and implementation-wise—so that it can be handed to another engineer or agent to be implemented right away. It must be **decision complete**, where the implementer does not need to make any decisions.
+
+## Mode rules (strict)
+
+You are in **Plan Mode** until a developer message explicitly ends it.
+
+Plan Mode is not changed by user intent, tone, or imperative language. If a user asks for execution while still in Plan Mode, treat it as a request to **plan the execution**, not perform it.
+
+## Execution vs. mutation in Plan Mode
+
+You may explore and execute **non-mutating** actions that improve the plan. You must not perform **mutating** actions.
+
+### Allowed (non-mutating, plan-improving)
+
+Actions that gather truth, reduce ambiguity, or validate feasibility without changing repo-tracked state. Examples:
+
+* Reading or searching files, configs, schemas, types, manifests, and docs
+* Static analysis, inspection, and repo exploration
+* Dry-run style commands when they do not edit repo-tracked files
+* Tests, builds, or checks that may write to caches or build artifacts (for example, \`target/\`, \`.cache/\`, or snapshots) so long as they do not edit repo-tracked files
+
+### Not allowed (mutating, plan-executing)
+
+Actions that implement the plan or change repo-tracked state. Examples:
+
+* Editing or writing files
+* Running formatters or linters that rewrite files
+* Applying patches, migrations, or codegen that updates repo-tracked files
+* Side-effectful commands whose purpose is to carry out the plan rather than refine it
+
+When in doubt: if the action would reasonably be described as "doing the work" rather than "planning the work," do not do it.
+
+## Research tracking
+
+Track your discoveries, open questions, and resolved questions as you explore. Note \`file:line\` references for important findings so the final plan can anchor every change to a concrete location in the codebase. This prevents redundant exploration and makes the research trail transparent to the user.
+
+## Powerful exploration tools
+
+You have access to powerful tools for codebase exploration—use them liberally:
+
+* **CodeSearch**: Use this for semantic code search. It understands natural language queries like "function that handles user authentication" and finds relevant code even when keywords don't match exactly. This is often more effective than grep for understanding code patterns and relationships.
+* **codebase-researcher subagent**: When you need thorough investigation of a feature, system, or component, launch the codebase-researcher subagent to perform deep exploration. Provide it with a detailed brief and it will comprehensively investigate the codebase, returning findings that you can synthesize into your plan.
+
+For complex tasks, consider: (1) launching the codebase-researcher in parallel while you explore other areas, (2) using CodeSearch to find related patterns across the codebase, then (3) synthesizing findings into your plan.
+
+## PHASE 1 — Ground in the environment (explore first, ask second)
+
+Begin by grounding yourself in the actual environment. Eliminate unknowns in the prompt by discovering facts, not by asking the user. Resolve all questions that can be answered through exploration or inspection. Identify missing or ambiguous details only if they cannot be derived from the environment. Silent exploration between turns is allowed and encouraged.
+
+Before asking the user any question, perform at least one targeted non-mutating exploration pass (for example: search relevant files, inspect likely entrypoints/configs, confirm current implementation shape), unless no local environment/repo is available.
+
+Exception: you may ask clarifying questions about the user's prompt before exploring, ONLY if there are obvious ambiguities or contradictions in the prompt itself. However, if ambiguity might be resolved by exploring, always prefer exploring first.
+
+Do not ask questions that can be answered from the repo or system (for example, "where is this struct?" or "which UI component should we use?" when exploration can make it clear). Only ask once you have exhausted reasonable non-mutating exploration.
+
+## PHASE 2 — Intent chat (what they actually want)
+
+* Keep asking until you can clearly state: goal + success criteria, audience, in/out of scope, constraints, current state, and the key preferences/tradeoffs.
+* Require an explicit **"Out of Scope"** statement — what we are NOT doing. This prevents scope creep and sets clear expectations.
+* Be skeptical: actively challenge vague requirements, identify issues early, and verify assumptions against code rather than accepting them at face value.
+* Bias toward questions over guessing: if any high-impact ambiguity remains, do NOT plan yet—ask.
+
+## PHASE 3 — Implementation chat (what/how we’ll build)
+
+* Once intent is stable, keep asking until the spec is decision complete: approach, interfaces (APIs/schemas/I/O), data flow, edge cases/failure modes, testing + acceptance criteria, rollout/monitoring, and any migrations/compat constraints.
+* **Propose a plan outline first**: before writing the full detailed plan, present a high-level outline of implementation phases — each with a name and what it accomplishes. Get user feedback on structure before filling in details.
+* **Migration, rollback, and backwards compatibility**: when applicable, give these dedicated attention. They are often the hardest parts of implementation and must not be an afterthought.
+* **Common implementation sequencing** — use these as reference when ordering phases:
+  * Database changes: schema/migration → store methods → business logic → API → clients
+  * New features: research existing patterns → data model → backend logic → API endpoints → UI
+  * Refactoring: document current behavior → plan incremental changes → maintain backwards compatibility → migration strategy
+
+## Asking questions
+
+Critical rules:
+
+* Offer meaningful multiple‑choice options when possible; don’t include filler choices that are obviously wrong or irrelevant.
+
+You SHOULD ask many questions, but each question must:
+
+* materially change the spec/plan, OR
+* confirm/lock an assumption, OR
+* choose between meaningful tradeoffs.
+* not be answerable by non-mutating commands.
+
+## Two kinds of unknowns (treat differently)
+
+1. **Discoverable facts** (repo/system truth): explore first.
+
+   * Before asking, run targeted searches and check likely sources of truth (configs/manifests/entrypoints/schemas/types/constants).
+   * Ask only if: multiple plausible candidates; nothing found but you need a missing identifier/context; or ambiguity is actually product intent.
+   * If asking, present concrete candidates (paths/service names) + recommend one.
+   * Never ask questions you can answer from your environment (e.g., “where is this struct”).
+
+2. **Preferences/tradeoffs** (not discoverable): ask early.
+
+   * These are intent or implementation preferences that cannot be derived from exploration.
+   * Provide 2–4 mutually exclusive options + a recommended default.
+   * If unanswered, proceed with the recommended option and record it as an assumption in the final plan.
+
+## Finalization rule
+
+Only output the final plan when it is decision complete and leaves no decisions to the implementer.
+
+When you present the official plan, wrap it in a \`<proposed_plan>\` block so the client can render it specially:
+
+1) The opening tag must be on its own line.
+2) Start the plan content on the next line (no text on the same line as the tag).
+3) The closing tag must be on its own line.
+4) Use Markdown inside the block.
+5) Keep the tags exactly as \`<proposed_plan>\` and \`</proposed_plan>\` (do not translate or rename them), even if the plan content is in another language.
+
+Example:
+
+<proposed_plan>
+plan content
+</proposed_plan>
+
+plan content should be human and agent digestible. The final plan must be plan-only and include:
+
+* A clear title
+* A brief summary section
+* Important changes or additions to public APIs/interfaces/types
+* Specific \`file:line\` references for all code locations the plan touches
+* An explicit **"Out of Scope"** section
+* **Success criteria** separated into two categories:
+  * **Automated verification** — commands that can be run (test, lint, typecheck, build) and specific files/code that should exist or compile
+  * **Manual verification** — UI/UX functionality, performance under real conditions, hard-to-automate edge cases, user acceptance criteria
+* Migration/rollback strategy when applicable
+* Explicit assumptions and defaults chosen where needed
+
+Do not ask "should I proceed?" in the final output. The user can easily switch out of Plan mode and request implementation if you have included a \`<proposed_plan>\` block in your response. Alternatively, they can decide to stay in Plan mode and continue refining the plan.
+
+Only produce at most one \`<proposed_plan>\` block per turn, and only when you are presenting a complete spec.
+
+## Plan acceptance
+
+After presenting a \`<proposed_plan>\` block, explicitly ask the user if they accept the plan. If they accept (e.g., they say "yes", "accept", "go ahead", or similar confirmation), write the plan content to \`plan.md\` in the current working directory using the Write tool. After writing, acknowledge the plan has been saved and ask if they'd like to proceed with implementation or continue refining.
+`;

package/dist/prompts/mentions.d.ts

@@ -0,0 +1,11 @@
+import type { ModelMetadata } from "../models/providers.ts";
+import type { ContextItem } from "./manager.ts";
+export declare function processPrompt(message: string, { baseDir, model, pasteStore, }: {
+    baseDir: string;
+    model: ModelMetadata;
+    pasteStore?: Map<number, string>;
+}): Promise<{
+    message: string;
+    context: ContextItem[];
+}>;
+//# sourceMappingURL=mentions.d.ts.map

package/dist/prompts/mentions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mentions.d.ts","sourceRoot":"","sources":["../../source/prompts/mentions.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAG5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAwGhD,wBAAsB,aAAa,CACjC,OAAO,EAAE,MAAM,EACf,EACE,OAAO,EACP,KAAK,EACL,UAAU,GACX,EAAE;IACD,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,aAAa,CAAC;IACrB,UAAU,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC,GACA,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,WAAW,EAAE,CAAA;CAAE,CAAC,CAwDtD"}

package/dist/{mentions.js → prompts/mentions.js}

@@ -1,48 +1,31 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { initExecutionEnvironment } from "./execution/index.js";
-import { formatFile } from "./formatting.js";
-class ShellCommandError extends Error {
-    command;
-    exitCode;
-    output;
-    constructor(message, command, exitCode, output) {
-        super(message);
-        this.name = "ShellCommandError";
-        this.command = command;
-        this.exitCode = exitCode;
-        this.output = output;
+import { formatFile } from "../utils/formatting.js";
+async function readFileEntry(fullPath, relativeFilePath, format) {
+    try {
+        const fileContents = await fs.readFile(fullPath, "utf8");
+        return formatFile(relativeFilePath, fileContents, format);
+    }
+    catch (error) {
+        return `Error reading file ${relativeFilePath}: ${error instanceof Error ? error.message : "Unknown error"}`;
     }
 }
-export class PromptError extends Error {
-    constructor(message, cause) {
-        super(message, { cause });
-        this.name = "PromptError";
+async function collectFiles(currentPath, format, allContents, relativePath = "") {
+    const entries = await fs.readdir(currentPath, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(currentPath, entry.name);
+        const relativeFilePath = path.join(relativePath, entry.name);
+        if (entry.isDirectory()) {
+            await collectFiles(fullPath, format, allContents, relativeFilePath);
+        }
+        else if (entry.isFile()) {
+            allContents.push(await readFileEntry(fullPath, relativeFilePath, format));
+        }
     }
 }
-// Helper function to recursively read all files in a directory
 async function readDirectoryRecursive(dirPath, format) {
     const allContents = [];
-    async function readDir(currentPath, relativePath = "") {
-        const entries = await fs.readdir(currentPath, { withFileTypes: true });
-        for (const entry of entries) {
-            const fullPath = path.join(currentPath, entry.name);
-            const relativeFilePath = path.join(relativePath, entry.name);
-            if (entry.isDirectory()) {
-                await readDir(fullPath, relativeFilePath);
-            }
-            else if (entry.isFile()) {
-                try {
-                    const fileContents = await fs.readFile(fullPath, "utf8");
-                    allContents.push(formatFile(relativeFilePath, fileContents, format));
-                }
-                catch (error) {
-                    allContents.push(`Error reading file ${relativeFilePath}: ${error instanceof Error ? error.message : "Unknown error"}`);
-                }
-            }
-        }
-    }
-    await readDir(dirPath);
+    await collectFiles(dirPath, format, allContents);
     if (allContents.length === 0) {
         return `Directory ${path.basename(dirPath)} is empty or contains no readable files.`;
     }
@@ -91,34 +74,10 @@ async function processFileCommand(context) {
         return `Error accessing ${filePath}: An unknown error occurred.`;
     }
 }
-async function processShellCommand(command) {
-    try {
-        const execEnv = await initExecutionEnvironment();
-        const { output, exitCode } = await execEnv.executeCommand(command, {
-            throwOnError: true,
-        });
-        if (exitCode === 0) {
-            return output;
-        }
-        throw new ShellCommandError(`Command failed with exit code ${exitCode}`, command, exitCode, output);
-    }
-    catch (error) {
-        if (error instanceof ShellCommandError) {
-            throw error;
-        }
-        if (error instanceof Error) {
-            throw new ShellCommandError(`Command execution failed: ${error.message}`, command, undefined, undefined);
-        }
-        throw new ShellCommandError("Command execution failed with unknown error", command, undefined, undefined);
-    }
-}
-// Returns the formatted string or an error message string
 export async function processPrompt(message, { baseDir, model, pasteStore, }) {
-    const fileRegex = /@([^\s@]+(?:\.[\w\d]+))/g;
-    const shellRegex = /!`([^`]+)`/g;
+    const fileRegex = /(?<![a-zA-Z0-9_-])#([a-zA-Z_][^\s#]*?(?:\.[a-zA-Z0-9]+)?)(?![^\s#]*#[\d.]+)/g;
     // Collect all matches for files
     const fileMatches = Array.from(message.matchAll(fileRegex));
-    const shellMatches = Array.from(message.matchAll(shellRegex));
     const mentionProcessingPromises = [];
     // Process file references - collect promises
     for (const match of fileMatches) {
@@ -148,24 +107,6 @@ export async function processPrompt(message, { baseDir, model, pasteStore, }) {
             match = pasteRegex.exec(processedMessage);
         }
     }
-    // Process shell commands
-    for (const match of shellMatches) {
-        const command = match[1];
-        if (command) {
-            try {
-                const output = await processShellCommand(command);
-                processedMessage = processedMessage.replace(match[0], output);
-            }
-            catch (error) {
-                if (error instanceof ShellCommandError) {
-                    // Wrap shell command errors in PromptError
-                    throw new PromptError(`Shell command failed: ${error.message}`, error);
-                }
-                // For other errors, wrap them in PromptError
-                throw new PromptError(`Unexpected error executing command: ${error instanceof Error ? error.message : "Unknown error"}`, error instanceof Error ? error : undefined);
-            }
-        }
-    }
     // Wait for all mentions to be processed
     const mentionResults = await Promise.all(mentionProcessingPromises);
     const context = [];

package/dist/prompts/system-prompt.d.ts

@@ -0,0 +1,26 @@
+import type { CompleteToolNames } from "../tools/index.ts";
+type SystemPromptComponents = {
+    core: string;
+    userAgentsMd: string;
+    cwdAgentsMd: string;
+    learnedRules: string;
+    skills: string;
+    subagents: string;
+};
+export declare function environmentInfo(currentWorkingDir: string, allowedDirs: string[], logsPath?: string): Promise<string>;
+type SystemPromptOptions = {
+    currentWorkingDir?: string;
+    allowedDirs?: string[];
+    logsPath?: string;
+    activeTools?: CompleteToolNames[];
+    includeRules?: boolean;
+    skillsEnabled?: boolean;
+    minimalPrompt?: boolean;
+};
+type SystemPromptResult = {
+    prompt: string;
+    components: SystemPromptComponents;
+};
+export declare function systemPrompt(options?: SystemPromptOptions): Promise<SystemPromptResult>;
+export {};
+//# sourceMappingURL=system-prompt.d.ts.map

package/dist/prompts/system-prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-prompt.d.ts","sourceRoot":"","sources":["../../source/prompts/system-prompt.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAI3D,KAAK,sBAAsB,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAsCF,wBAAsB,eAAe,CACnC,iBAAiB,EAAE,MAAM,EACzB,WAAW,EAAE,MAAM,EAAE,EACrB,QAAQ,CAAC,EAAE,MAAM,mBA+BlB;AAED,KAAK,mBAAmB,GAAG;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,iBAAiB,EAAE,CAAC;IAClC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,KAAK,kBAAkB,GAAG;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,sBAAsB,CAAC;CACpC,CAAC;AAKF,wBAAsB,YAAY,CAChC,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,kBAAkB,CAAC,CAyK7B"}

package/dist/{prompts.js → prompts/system-prompt.js}

@@ -1,16 +1,17 @@
 import { platform } from "node:os";
-import { config } from "./config.js";
-import { dedent } from "./dedent.js";
-import { formatSkillsForPrompt, loadSkills } from "./skills.js";
-import { getShell } from "./terminal/index.js";
-import { getCurrentBranch, inGitDirectory } from "./utils/git.js";
+import { config } from "../config/index.js";
+import { formatSkillsForPrompt, loadSkills } from "../skills/index.js";
+import { formatSubagentsForPrompt, loadSubagents } from "../subagents/index.js";
+import { getShell } from "../terminal/index.js";
+import { dedent } from "../utils/dedent.js";
+import { getCurrentBranch, inGitDirectory } from "../utils/git.js";
 async function getProjectContext() {
     const agentsFiles = await config.readAgentsFiles();
     const userAgentsFile = agentsFiles.find((f) => f.path === "~/.acai/AGENTS.md");
     const cwdAgentsFile = agentsFiles.find((f) => f.path === "./AGENTS.md");
     const userRules = (userAgentsFile?.content ?? "").trim();
     const cwdRules = (cwdAgentsFile?.content ?? "").trim();
-    const learnedRules = (await config.readProjectLearnedRulesFile()).trim();
+    const learnedRules = (await config.readLearnedRulesFile()).trim();
     let result = "";
     if (userRules || cwdRules) {
         result += "## Project Context:\n\n";
@@ -27,19 +28,33 @@ async function getProjectContext() {
         }
         result += `### Important rules to follow\n\n${learnedRules}`;
     }
-    return result.trim();
+    return {
+        text: result.trim(),
+        userAgentsMd: userRules,
+        cwdAgentsMd: cwdRules,
+        learnedRules: learnedRules,
+    };
 }
-async function environmentInfo(allowedDirs) {
+export async function environmentInfo(currentWorkingDir, allowedDirs, logsPath) {
     const gitDirectory = await inGitDirectory();
     let gitSection = `- **Is directory a git repo**: ${gitDirectory ? "Yes" : "No"}`;
     if (gitDirectory) {
         gitSection += `\n- **Current git branch**: ${await getCurrentBranch()}`;
     }
+    let logsSection = "";
+    if (logsPath) {
+        logsSection = `
+### Project logs:
+
+- ${logsPath}`;
+    }
     return `## Environment
+### Current working directory:
+${currentWorkingDir}
 
 ### Allowed directories:
 
-${allowedDirs.map((dir) => `- ${dir}`).join("\n")}
+${allowedDirs.map((dir) => `- ${dir}`).join("\n")}${logsSection}
 
 ### Information:
 
@@ -47,20 +62,27 @@ ${gitSection}
 - **Platform**: ${platform()}
 - **Shell**: ${getShell()}
 - **Today's date**: ${new Date().toISOString().split("T")[0]}
-
-- Note: The .tmp directory in the current working directory is deleted each time the agent shuts down.`;
+`;
 }
-const DEFAULT_ALLOWED_DIRS = [process.cwd()];
+const DEFAULT_WORKING_DIRS = process.cwd();
+const DEFAULT_ALLOWED_DIR = [process.cwd()];
 export async function systemPrompt(options) {
-    const { allowedDirs = DEFAULT_ALLOWED_DIRS, includeRules = true, skillsEnabled = true, } = options ?? {};
-    const projectContextText = includeRules ? await getProjectContext() : "";
-    const environmentInfoText = await environmentInfo(allowedDirs);
+    const { currentWorkingDir = DEFAULT_WORKING_DIRS, allowedDirs = DEFAULT_ALLOWED_DIR, logsPath, includeRules = true, skillsEnabled = true, minimalPrompt = true, } = options ?? {};
+    const projectContextResult = includeRules
+        ? await getProjectContext()
+        : { text: "", userAgentsMd: "", cwdAgentsMd: "", learnedRules: "" };
+    const projectContextText = projectContextResult.text;
+    const environmentInfoText = await environmentInfo(currentWorkingDir, allowedDirs, logsPath);
     let skillsText = "";
     if (skillsEnabled) {
         const skills = await loadSkills();
-        skillsText = formatSkillsForPrompt(skills);
+        skillsText = formatSkillsForPrompt(skills.getModelInvocable());
     }
-    const prompt = dedent `
+    const subagents = await loadSubagents();
+    const subagentsText = formatSubagentsForPrompt(subagents);
+    const corePrompt = minimalPrompt
+        ? "You are acai. You are running as a coding agent in a CLI on the user's computer."
+        : dedent `
 You are acai. You are running as a coding agent in a CLI on the user's computer.
 
 ## Core Principles
@@ -184,10 +206,16 @@ DEFAULT TO PARALLEL: Unless you have a specific reason why operations MUST be se
 - Apply principle of least privilege in API integrations
 - If a tool fails, ask the user how to proceed
 - Report errors with specific locations and suggested fixes
-
-${projectContextText}
-
-${environmentInfoText}${skillsText}
 `;
-    return prompt;
+    const components = {
+        core: `${corePrompt}\n\n${environmentInfoText}`,
+        userAgentsMd: projectContextResult.userAgentsMd,
+        cwdAgentsMd: projectContextResult.cwdAgentsMd,
+        learnedRules: projectContextResult.learnedRules,
+        skills: skillsText,
+        subagents: subagentsText,
+    };
+    const assembledPrompt = `${corePrompt}\n${projectContextText}\n\n${environmentInfoText}${skillsText}\n\n${subagentsText}`;
+    const result = { prompt: assembledPrompt, components };
+    return result;
 }

package/dist/repl/index.d.ts

@@ -0,0 +1,174 @@
+import type { Agent, AgentEvent, AgentState } from "../agent/index.ts";
+import type { CommandManager } from "../commands/manager.ts";
+import type { ConfigManager } from "../config/index.ts";
+import type { WorkspaceContext } from "../index.ts";
+import type { ModelManager } from "../models/manager.ts";
+import type { PromptManager } from "../prompts/manager.ts";
+import { type SessionManager } from "../sessions/manager.ts";
+import type { TokenCounter } from "../tokens/counter.ts";
+import type { TokenTracker } from "../tokens/tracker.ts";
+import type { CompleteToolSet } from "../tools/index.ts";
+import type { ProcessTerminalOptions } from "../tui/terminal.ts";
+/** Configuration options for the REPL instance. */
+interface ReplOptions {
+    /** The AI agent that processes user prompts and generates responses. */
+    agent: Agent;
+    /** Manages session persistence, message history, and metadata. */
+    sessionManager: SessionManager;
+    /** Manages prompt construction including context injection. */
+    promptManager: PromptManager;
+    /** Manages model selection and metadata retrieval. */
+    modelManager: ModelManager;
+    /** Tracks token usage across the session. */
+    tokenTracker: TokenTracker;
+    /** Handles slash command parsing and execution. */
+    commands: CommandManager;
+    /** Application configuration manager for rule generation, etc. */
+    configManager: ConfigManager;
+    /** Counts tokens for prompt budgeting. */
+    tokenCounter: TokenCounter;
+    /** History of previously submitted prompts for recall. */
+    promptHistory: string[];
+    /** Workspace context including allowed directories. */
+    workspace: WorkspaceContext;
+    /** Optional complete set of tools available to the agent. */
+    tools?: CompleteToolSet;
+    /** Optional terminal configuration for the process terminal. */
+    terminalOptions?: ProcessTerminalOptions;
+    /** If true, don't save session to disk. */
+    noSession?: boolean;
+}
+/**
+ * Interactive Read-Eval-Print Loop that provides the primary user interface
+ * for the AI assistant CLI. Manages the TUI layout, handles keyboard shortcuts,
+ * processes agent events for streaming responses, and coordinates session lifecycle.
+ */
+export declare class Repl {
+    private options;
+    private terminal;
+    private tui;
+    private welcome;
+    private editor;
+    private chatContainer;
+    private statusContainer;
+    private footer;
+    private editorContainer;
+    private notification;
+    private isInitialized;
+    private onInputCallback?;
+    private loadingAnimation;
+    private onInterruptCallback?;
+    private onExitCallback?;
+    private lastSigintTime;
+    private exitNotificationTimer?;
+    private pendingTools;
+    private tools?;
+    private streamingComponent;
+    private thinkingBlockComponent;
+    private allThinkingBlocks;
+    private allToolExecutions;
+    private verboseMode;
+    private modeManager;
+    private config;
+    /** Creates a new Repl instance, initializing the TUI layout and components. */
+    constructor(options: ReplOptions);
+    /**
+     * Initializes the REPL by setting up autocomplete,
+     * keyboard handlers, and the TUI component tree.
+     */
+    init(): Promise<void>;
+    /**
+     * Handles an agent event by updating the TUI accordingly.
+     * Processes events such as streaming messages, tool calls, thinking blocks,
+     * and agent lifecycle transitions (start, stop, error).
+     */
+    handle(event: AgentEvent, state: AgentState): Promise<void>;
+    /** Adds a user message component to the chat container. */
+    private addMessageToChat;
+    /**
+     * Adds a component to the chat container with spacing.
+     * Adds a Spacer(1) before every component (including the first).
+     */
+    private addComponentWithSpacing;
+    /** Returns a promise that resolves with the user's next input submission. */
+    getUserInput(): Promise<string>;
+    /** Clears the editor input and triggers a re-render. */
+    clearEditor(): void;
+    /**
+     * Sets the callback invoked when the user presses
+     * Escape to interrupt the agent.
+     */
+    setInterruptCallback(callback: () => void): void;
+    /** Sets the callback invoked on exit, receiving the current session ID. */
+    setExitCallback(callback: (sessionId: string) => void | Promise<void>): void;
+    /**
+     * Re-renders the entire session by restoring mode state,
+     * replaying token usage, and reconstructing the chat
+     * display.
+     */
+    rerender(): Promise<void>;
+    /**
+     * Rebuilds the chat container from the full session
+     * message history, including user messages, assistant
+     * responses, and tool executions.
+     */
+    private reconstructSession;
+    /**
+     * Extracts the text content from a user message,
+     * handling both string and array content formats.
+     */
+    private extractUserMessageText;
+    /**
+     * Renders an assistant message into the chat container,
+     * including reasoning/thinking blocks and text content.
+     */
+    private renderAssistantMessage;
+    /**
+     * Extracts tool call content parts from an assistant
+     * message, matching them with their corresponding
+     * tool results.
+     */
+    private extractToolCallsFromAssistant;
+    /**
+     * Creates start and end/error ToolEvent pairs from a
+     * resolved tool call, using the tool's display function
+     * when available.
+     */
+    private createToolEvents;
+    /**
+     * Toggles verbose mode on/off, updating all thinking
+     * block and tool execution components.
+     */
+    private handleCtrlO;
+    /**
+     * Starts a new session by saving the current one,
+     * resetting mode/tokens/UI, and clearing the chat.
+     */
+    private handleCtrlN;
+    private handleCtrlM;
+    /** Handles Ctrl+D to exit the REPL when the editor is empty. */
+    private handleCtrlD;
+    /**
+     * Handles Ctrl+C with double-press-to-exit logic.
+     * First press clears the editor; second press within
+     * 1 second exits.
+     */
+    private handleCtrlC;
+    /**
+     * Stops the REPL, cleaning up timers, animations,
+     * and the TUI. Optionally triggers the exit callback.
+     */
+    stop(showExitMessage?: boolean): void;
+    /**
+     * Generates rules automatically if autoGenerateRules is enabled
+     * and the session has messages.
+     */
+    private maybeGenerateRules;
+    /**
+     * Triggers rule generation for use before exit.
+     * Returns a promise that resolves when rules are generated.
+     */
+    triggerRuleGeneration(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/repl/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/repl/index.ts"],"names":[],"mappings":"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"}