@travisennis/acai 0.0.1

package/dist/prompts.js

@@ -0,0 +1,158 @@
+import { readFile } from "node:fs/promises";
+import { platform } from "node:os";
+import path from "node:path";
+import { config } from "./config.js";
+import { dedent } from "./dedent.js";
+import { AgentTool } from "./tools/agent.js";
+import { BashTool } from "./tools/bash.js";
+import { CodeInterpreterTool } from "./tools/code-interpreter.js";
+import { DirectoryTreeTool } from "./tools/directory-tree.js";
+import { EditFileTool } from "./tools/edit-file.js";
+import { getCurrentBranch, inGitDirectory } from "./tools/git-utils.js";
+import { GrepTool } from "./tools/grep.js";
+import { ReadFileTool } from "./tools/read-file.js";
+import { SaveFileTool } from "./tools/save-file.js";
+import { ThinkTool } from "./tools/think.js";
+import { WebFetchTool } from "./tools/web-fetch.js";
+import { WebSearchTool } from "./tools/web-search.js";
+function intro() {
+    return "You are acai, an AI-powered CLI assistant that accelerates software engineering workflows through intelligent command-line assistance.";
+}
+async function instructions() {
+    const systemMdPath = path.join(config.project.getPath(), "system.md");
+    try {
+        const content = await readFile(systemMdPath, "utf8");
+        if (content.trim()) {
+            return content;
+        }
+    }
+    catch {
+        // system.md doesn't exist or is empty, use default instructions
+    }
+    return `## Core Principles
+
+- **CLI-Optimized**: Be concise and direct - responses appear in a terminal.
+- **Progressive Problem Solving**: Work through problems methodically until resolution.
+- **User Authority**: NEVER commit changes or add dependencies without explicit user approval.
+- **Security-First**: Prioritize secure coding practices in all suggestions.
+- **Completion Focus**: Continue working until the user's query is completely resolved.
+- **Expert Level**: Assume the user is an experienced software engineer.
+
+## Response Format
+
+- **Direct Answers**: One-word or concise answers when possible.
+- **Code First**: Lead with code snippets for code-related queries.
+- **No Fluff**: Avoid preambles or phrases like "Here is the content..."
+- **Error Reporting**: Specify error, location, and fix (e.g., \`Error: TypeError at auth.ts:42. Fix: Add null check.\`).
+
+## Work Standards
+
+### Code Quality
+- Match existing code conventions and patterns
+- Use libraries/utilities already in the project
+- Prioritize maintainable, readable code over clever solutions
+
+### Security & Error Handling
+- Validate/sanitize all inputs and outputs
+- Use parameterized queries for databases
+- Never hardcode secrets; prevent injection attacks, XSS, unauthorized access
+- 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`;
+}
+function toolUsage() {
+    return `## Tool Usage Guidelines
+
+### Information Gathering
+- Use \`${DirectoryTreeTool.name}\` for project structure
+- Use \`${ReadFileTool.name}\` for file contents if filenames are provided in the prompt
+- Use \`${GrepTool.name}\` for code pattern searches
+- Use \`${WebFetchTool.name}\` for text-based URLs provided in the prompt
+- Use \`${WebSearchTool.name}\` for external research (e.g., libraries, errors)
+- Use \`${AgentTool.name}\` for iterative keyword/file searches
+- If file contents or URLs are provided in the prompt, use them directly without re-fetching
+- Always verify file contents before suggesting changes unless provided in the prompt
+
+### Code Modification
+- Use \`${EditFileTool.name}\` for existing file edits (requires user approval)
+- Use \`${SaveFileTool.name}\` for new files only
+
+### Planning & Complex Tasks
+- Use \`${ThinkTool.name}\` for structured reasoning on complex problems
+- Outline multi-step tasks before execution
+
+### Bash Commands (\`${BashTool.name}\`)
+- Execute bash commands within project directory only
+- Always specify absolute paths to avoid errors
+- You have access to the Github CLI
+- **Background Processes:** Use background processes (via \`&\`) for commands that are unlikely to stop on their own, e.g. \`node server.js &\`. If unsure, ask the user.
+- **Interactive Commands:** Try to avoid shell commands that are likely to require user interaction (e.g. \`git rebase -i\`). Use non-interactive versions of commands (e.g. \`npm init -y\` instead of \`npm init\`) when available, and otherwise remind the user that interactive shell commands are not supported and may cause hangs until canceled by the user.
+
+### Code Interpreter (\`${CodeInterpreterTool.name}\`)
+- Executes JavaScript code in a separate Node.js process using Node's Permission Model
+- By default, the child process has no permissions except read/write within the current working directory
+- Returns stdout, stderr, and exitCode
+- Use console.log/console.error to produce outpu`;
+}
+function escalationProcedures() {
+    return `## Escalation
+
+- If stuck, state the limitation, suggest alternatives, and ask the user for guidance`;
+}
+async function getRules() {
+    const rules = (await config.readAgentsFile()).trim();
+    const learnedRules = (await config.readProjectLearnedRulesFile()).trim();
+    let result = "";
+    if (rules) {
+        result += `## Project Rules:\n\n${rules}\n`;
+    }
+    if (learnedRules) {
+        if (!rules) {
+            result += "## Project Rules:\n\n";
+        }
+        result += `### Important rules to follow\n\n${learnedRules}`;
+    }
+    return result.trim();
+}
+async function environmentInfo() {
+    const gitDirectory = await inGitDirectory();
+    let gitSection = `- **Is directory a git repo**: ${gitDirectory ? "Yes" : "No"}`;
+    if (gitDirectory) {
+        gitSection += `\n- ** Current git branch**: ${await getCurrentBranch()}`;
+    }
+    return `## Environment
+
+- **Current working directory**: ${process.cwd()}. [Use this value directly instead of calling the \`${BashTool.name}(pwd)\` tool unless you have a specific reason to verify it].
+${gitSection}
+- **Platform**: ${platform()}
+- **Today's date**: ${(new Date()).toISOString()}`;
+}
+export async function systemPrompt(options) {
+    const { supportsToolCalling = true } = options ?? {};
+    const prompt = dedent `
+${intro()}
+
+${await instructions()}
+
+${supportsToolCalling ? toolUsage() : ""}
+
+${escalationProcedures()}
+
+${await getRules()}
+
+${await environmentInfo()}
+`;
+    return prompt;
+}
+export async function minSystemPrompt() {
+    const prompt = dedent `
+${intro()}
+
+${await instructions()}
+
+${await getRules()}
+
+${await environmentInfo()}
+`;
+    return prompt;
+}

package/dist/repl-prompt.d.ts

@@ -0,0 +1,14 @@
+import type { CommandManager } from "./commands/manager.ts";
+export declare class ReplPrompt {
+    private keypressListener?;
+    private rl;
+    private history;
+    private maxHistory;
+    constructor({ commands, history, }: {
+        commands: CommandManager;
+        history: string[];
+    });
+    input(): Promise<string>;
+    close(): void;
+    [Symbol.dispose](): void;
+}

package/dist/repl-prompt.js

@@ -0,0 +1,147 @@
+import { readdir } from "node:fs/promises";
+import { parse, sep } from "node:path";
+import { createInterface } from "node:readline/promises";
+import Clipboard from "@crosscopy/clipboard";
+import { asyncTry } from "@travisennis/stdlib/try";
+import { logger } from "./logger.js";
+const whitespaceRegex = /\s+/;
+async function fileSystemCompleter(line) {
+    try {
+        const words = line.split(" ");
+        let last = words.at(-1);
+        if (!last) {
+            return [[], line];
+        }
+        const isAt = last.startsWith("@");
+        if (isAt) {
+            last = last.slice(1);
+        }
+        let { dir, base } = parse(last);
+        // If dir is empty, use current directory
+        if (!dir) {
+            dir = ".";
+        }
+        let tryAttempt = await asyncTry(readdir(dir, { withFileTypes: true }));
+        if (tryAttempt.isFailure) {
+            tryAttempt = await asyncTry(readdir(".", { withFileTypes: true }));
+        }
+        let dirEntries = tryAttempt.unwrap();
+        // for an exact match that is a directory, read the contents of the directory
+        if (dirEntries.find((entry) => entry.name === base && entry.isDirectory())) {
+            dir = dir === "/" || dir === sep ? `${dir}${base}` : `${dir}/${base}`;
+            dirEntries = await readdir(dir, { withFileTypes: true });
+            base = "";
+        }
+        else {
+            dirEntries = dirEntries.filter((entry) => entry.name.startsWith(base));
+        }
+        const hits = dirEntries
+            .filter((entry) => entry.isFile() || entry.isDirectory())
+            .map((entry) => {
+            const prefix = dir === "." ? "" : dir === sep || dir === "/" ? "" : `${dir}/`;
+            return `${isAt ? "@" : ""}${prefix}${entry.name}${entry.isDirectory() && !entry.name.endsWith("/") ? "/" : ""}`;
+        });
+        return [hits, `${isAt ? "@" : ""}${last}`];
+    }
+    catch (_error) {
+        logger.error(_error);
+        return [[], line];
+    }
+}
+export class ReplPrompt {
+    // biome-ignore lint/suspicious/noExplicitAny: Keypress listener signature
+    keypressListener;
+    rl;
+    history;
+    maxHistory = 25;
+    constructor({ commands, history, }) {
+        this.history = history;
+        this.rl = createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            history: this.history,
+            historySize: this.maxHistory,
+            completer: async (line) => {
+                const completions = commands.getCommands();
+                const words = line.trim().split(whitespaceRegex);
+                const firstWord = words[0] ?? "";
+                const rest = words.slice(1).join(" ") ?? "";
+                const matchingCommands = completions.filter((c) => c.startsWith(firstWord));
+                if (matchingCommands.length === 1 && rest !== "") {
+                    // Single command matched, try to get subcommands
+                    const subCompletions = await commands.getSubCommands(matchingCommands[0] ?? "");
+                    const hits = subCompletions.filter((sc) => sc.startsWith(rest) || rest === "*");
+                    if (hits.length > 0) {
+                        return [hits.map((h) => `${firstWord} ${h}`), line];
+                    }
+                }
+                if (matchingCommands.length > 0 &&
+                    (words.length === 1 || line.endsWith(" "))) {
+                    return [matchingCommands, line];
+                }
+                return fileSystemCompleter(line); // [completions, line];
+            },
+        });
+        if (process.stdin.isTTY) {
+            this.keypressListener = async (_str, key) => {
+                // if (this.rl.closed) {
+                //   if (this.keypressListener) {
+                //     process.stdin.off("keypress", this.keypressListener);
+                //     this.keypressListener = undefined;
+                //   }
+                //   return;
+                // }
+                if (key?.ctrl && key.name === "v" && !key.meta && !key.shift) {
+                    try {
+                        const clipboardText = await Clipboard.getText();
+                        if (clipboardText) {
+                            const currentLine = this.rl.line;
+                            const cursorPos = this.rl.cursor;
+                            const beforeCursor = currentLine.substring(0, cursorPos);
+                            const afterCursor = currentLine.substring(cursorPos);
+                            const newLine = beforeCursor + clipboardText + afterCursor;
+                            // biome-ignore lint/suspicious/noExplicitAny: Accessing internal readline method
+                            this.rl.line = newLine;
+                            // biome-ignore lint/suspicious/noExplicitAny: Accessing internal readline method
+                            this.rl.cursor = cursorPos + clipboardText.length;
+                            // biome-ignore lint/suspicious/noExplicitAny: Accessing internal readline method
+                            this.rl._refreshLine();
+                        }
+                    }
+                    catch (error) {
+                        logger.error(`Failed to paste from clipboard: ${error.message}`);
+                    }
+                }
+            };
+            process.stdin.on("keypress", this.keypressListener);
+        }
+    }
+    async input() {
+        const input = await this.rl.question("> ");
+        // The readline interface automatically adds the input to the history.
+        // We need to handle two things:
+        // 1. Don't save empty lines.
+        // 2. Enforce max history size.
+        if (!input.trim()) {
+            // Last entry was this empty input, so remove it.
+            this.history.pop();
+        }
+        else {
+            // A valid command was added. Trim history if needed.
+            while (this.history.length > this.maxHistory) {
+                this.history.shift();
+            }
+        }
+        return input;
+    }
+    close() {
+        if (this.keypressListener) {
+            process.stdin.off("keypress", this.keypressListener);
+            this.keypressListener = undefined;
+        }
+        this.rl.close();
+    }
+    [Symbol.dispose]() {
+        this.close();
+    }
+}

package/dist/repl.d.ts

@@ -0,0 +1,27 @@
+import type { CommandManager } from "./commands/manager.ts";
+import type { MessageHistory } from "./messages.ts";
+import type { ModelManager } from "./models/manager.js";
+import type { PromptManager } from "./prompts/manager.ts";
+import type { Terminal } from "./terminal/index.ts";
+import type { TokenTracker } from "./token-tracker.ts";
+import type { TokenCounter } from "./token-utils.ts";
+import type { Message } from "./tools/types.ts";
+interface ReplOptions {
+    messageHistory: MessageHistory;
+    promptManager: PromptManager;
+    modelManager: ModelManager;
+    tokenTracker: TokenTracker;
+    terminal: Terminal;
+    commands: CommandManager;
+    config: Record<PropertyKey, unknown>;
+    tokenCounter: TokenCounter;
+    toolEvents: Map<string, Message[]>;
+    autoAcceptAll: boolean;
+}
+export declare class Repl {
+    private options;
+    constructor(options: ReplOptions);
+    run(): Promise<void>;
+    private displayToolUse;
+}
+export {};