@travisennis/acai 0.0.1

package/source/prompts.ts

@@ -0,0 +1,172 @@
+import { readFile } from "node:fs/promises";
+import { platform } from "node:os";
+import path from "node:path";
+import { config } from "./config.ts";
+import { dedent } from "./dedent.ts";
+import { AgentTool } from "./tools/agent.ts";
+import { BashTool } from "./tools/bash.ts";
+import { CodeInterpreterTool } from "./tools/code-interpreter.ts";
+import { DirectoryTreeTool } from "./tools/directory-tree.ts";
+import { EditFileTool } from "./tools/edit-file.ts";
+import { getCurrentBranch, inGitDirectory } from "./tools/git-utils.ts";
+import { GrepTool } from "./tools/grep.ts";
+import { ReadFileTool } from "./tools/read-file.ts";
+import { SaveFileTool } from "./tools/save-file.ts";
+import { ThinkTool } from "./tools/think.ts";
+import { WebFetchTool } from "./tools/web-fetch.ts";
+import { WebSearchTool } from "./tools/web-search.ts";
+
+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?: {
+  supportsToolCalling?: boolean;
+}) {
+  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/source/repl-prompt.ts

@@ -0,0 +1,196 @@
+import { readdir } from "node:fs/promises";
+import { parse, sep } from "node:path";
+import { createInterface, type Interface } from "node:readline/promises";
+import Clipboard from "@crosscopy/clipboard";
+import { asyncTry } from "@travisennis/stdlib/try";
+import type { CommandManager } from "./commands/manager.ts";
+import { logger } from "./logger.ts";
+
+const whitespaceRegex = /\s+/;
+
+async function fileSystemCompleter(line: string): Promise<[string[], string]> {
+  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
+  private keypressListener?: (str: string, key: any) => void;
+  private rl: Interface;
+  private history: string[];
+  private maxHistory = 25;
+
+  constructor({
+    commands,
+    history,
+  }: { commands: CommandManager; history: string[] }) {
+    this.history = history;
+
+    this.rl = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      history: this.history,
+      historySize: this.maxHistory,
+      completer: async (line): Promise<[string[], string]> => {
+        const completions = commands.getCommands();
+        const words = line.trim().split(whitespaceRegex);
+        const firstWord = words[0] ?? "";
+        const rest: string = 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: string,
+        key: {
+          name: string;
+          ctrl: boolean;
+          meta: boolean;
+          shift: boolean;
+          sequence: string;
+        },
+      ) => {
+        // 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 as any).line = newLine;
+              // biome-ignore lint/suspicious/noExplicitAny: Accessing internal readline method
+              (this.rl as any).cursor = cursorPos + clipboardText.length;
+
+              // biome-ignore lint/suspicious/noExplicitAny: Accessing internal readline method
+              (this.rl as any)._refreshLine();
+            }
+          } catch (error) {
+            logger.error(
+              `Failed to paste from clipboard: ${(error as 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();
+  }
+}