@travisennis/acai 0.0.1 → 0.0.3

package/dist/tools/git-utils.js

@@ -1,16 +1,48 @@
 import { memoize } from "@travisennis/stdlib/functional";
-import { simpleGit } from "simple-git";
 import { executeCommand } from "../utils/process.js";
 // Function to get diff stats
 export async function getDiffStat() {
-    const git = simpleGit(process.cwd());
     try {
         // Get diff stat comparing working directory to HEAD
-        const diffSummary = await git.diffSummary(["--stat"]);
+        const result = await executeCommand(["git", "diff", "--stat"], {
+            cwd: process.cwd(),
+            throwOnError: false,
+        });
+        if (result.code !== 0) {
+            console.error("Error getting git diff stat:", result.stderr);
+            return {
+                filesChanged: 0,
+                insertions: 0,
+                deletions: 0,
+            };
+        }
+        // Parse the git diff --stat output
+        // Example output: " 3 files changed, 15 insertions(+), 3 deletions(-)"
+        const statLine = result.stdout.trim();
+        if (!statLine) {
+            return {
+                filesChanged: 0,
+                insertions: 0,
+                deletions: 0,
+            };
+        }
+        // Extract numbers using regex
+        const filesMatch = statLine.match(/(\d+) files? changed/);
+        const insertionsMatch = statLine.match(/(\d+) insertion/);
+        const deletionsMatch = statLine.match(/(\d+) deletion/);
+        const filesChanged = filesMatch?.[1]
+            ? Number.parseInt(filesMatch[1], 10)
+            : 0;
+        const insertions = insertionsMatch?.[1]
+            ? Number.parseInt(insertionsMatch[1], 10)
+            : 0;
+        const deletions = deletionsMatch?.[1]
+            ? Number.parseInt(deletionsMatch[1], 10)
+            : 0;
         return {
-            filesChanged: diffSummary.files.length,
-            insertions: diffSummary.insertions,
-            deletions: diffSummary.deletions,
+            filesChanged,
+            insertions,
+            deletions,
         };
     }
     catch (error) {
@@ -23,6 +55,43 @@ export async function getDiffStat() {
         };
     }
 }
+export async function getGitStatus() {
+    // Git status processing (optimized)
+    const result = await executeCommand(["git", "status", "--porcelain"], {
+        cwd: process.cwd(),
+        throwOnError: false,
+    });
+    let added = 0;
+    let modified = 0;
+    let deleted = 0;
+    let untracked = 0;
+    if (result.code === 0) {
+        const lines = result.stdout.split("\n");
+        for (const line of lines) {
+            if (!line)
+                continue;
+            const s = line.slice(0, 2);
+            if (s[0] === "A" || s === "M ")
+                added++;
+            else if (s[1] === "M" || s === " M")
+                modified++;
+            else if (s[0] === "D" || s === " D")
+                deleted++;
+            else if (s === "??")
+                untracked++;
+        }
+        // if (added) gitStatus += ` +${added}`;
+        // if (modified) gitStatus += ` ~${modified}`;
+        // if (deleted) gitStatus += ` -${deleted}`;
+        // if (untracked) gitStatus += ` ?${untracked}`;
+    }
+    return {
+        added,
+        modified,
+        deleted,
+        untracked,
+    };
+}
 export const inGitDirectory = memoize(async () => {
     const { code } = await executeCommand(["git", "rev-parse", "--is-inside-work-tree"], {
         cwd: process.cwd(),
@@ -37,10 +106,13 @@ export async function hasUncommittedChanges() {
     if (!(await inGitDirectory())) {
         return false;
     }
-    const git = simpleGit(process.cwd());
     try {
-        const status = await git.status();
-        return status.files.length > 0;
+        const result = await executeCommand(["git", "status", "--porcelain"], {
+            cwd: process.cwd(),
+            throwOnError: false,
+        });
+        // If there are uncommitted changes, --porcelain will output lines for each changed file
+        return result.stdout.trim().length > 0;
     }
     catch {
         return false;
@@ -53,10 +125,15 @@ export async function getCurrentBranch() {
     if (!(await inGitDirectory())) {
         return null;
     }
-    const git = simpleGit(process.cwd());
     try {
-        const branch = await git.revparse(["--abbrev-ref", "HEAD"]);
-        return branch.trim();
+        const result = await executeCommand(["git", "rev-parse", "--abbrev-ref", "HEAD"], {
+            cwd: process.cwd(),
+            throwOnError: false,
+        });
+        if (result.code !== 0) {
+            return null;
+        }
+        return result.stdout.trim();
     }
     catch {
         return null;

package/dist/tools/grep.d.ts

@@ -13,5 +13,25 @@ export declare const createGrepTool: (options?: {
         filePattern: string | null;
         contextLines: number | null;
         searchIgnored: boolean | null;
+        literal: boolean | null;
     }, string>;
 };
+interface GrepOptions {
+    recursive?: boolean | null;
+    ignoreCase?: boolean | null;
+    filePattern?: string | null;
+    contextLines?: number | null;
+    searchIgnored?: boolean | null;
+    literal?: boolean | null;
+}
+/**
+ * Search files for patterns using ripgrep
+ *
+ * @param pattern - The regex pattern to search for
+ * @param path - The path to search in
+ * @param options - Additional options for the grep command
+ * @returns The result of the grep command
+ */
+export declare function buildGrepCommand(pattern: string, path: string, options?: GrepOptions): string;
+export declare function grepFiles(pattern: string, path: string, options?: GrepOptions): string;
+export {};

package/dist/tools/grep.js

@@ -34,20 +34,54 @@ export const createGrepTool = (options = {}) => {
                     .boolean()
                     .nullable()
                     .describe("Pass null to use the default (false, don't search ignored files)."),
+                literal: z
+                    .boolean()
+                    .nullable()
+                    .describe("Pass true to search as a fixed string (no regex). Pass null to auto-detect."),
             }),
-            execute: ({ pattern, path, recursive, ignoreCase, filePattern, contextLines, searchIgnored, }, { toolCallId }) => {
+            execute: ({ pattern, path, recursive, ignoreCase, filePattern, contextLines, searchIgnored, literal, }, { toolCallId }) => {
                 try {
                     sendData?.({
                         event: "tool-init",
                         id: toolCallId,
                         data: `Searching codebase for "${chalk.cyan(inspect(pattern))}" in ${chalk.cyan(path)}`,
                     });
+                    // Normalize literal option: if null => auto-detect using heuristic
+                    let effectiveLiteral = null;
+                    if (literal === true) {
+                        effectiveLiteral = true;
+                    }
+                    else if (literal === false) {
+                        effectiveLiteral = false;
+                    }
+                    else {
+                        // auto-detect
+                        try {
+                            if (likelyUnbalancedRegex(pattern)) {
+                                effectiveLiteral = true;
+                                sendData?.({
+                                    event: "tool-update",
+                                    id: toolCallId,
+                                    data: {
+                                        primary: "Pattern appears to contain unbalanced regex metacharacters; using fixed-string mode (-F).",
+                                    },
+                                });
+                            }
+                            else {
+                                effectiveLiteral = false;
+                            }
+                        }
+                        catch (_err) {
+                            effectiveLiteral = false;
+                        }
+                    }
                     const result = grepFiles(pattern, path, {
                         recursive,
                         ignoreCase,
                         filePattern,
                         contextLines,
                         searchIgnored,
+                        literal: effectiveLiteral,
                     });
                     const matchCount = result === "No matches found."
                         ? 0
@@ -58,11 +92,6 @@ export const createGrepTool = (options = {}) => {
                             if (line === "--") {
                                 return false;
                             }
-                            // A match line from ripgrep with --line-number has the format:
-                            // path:linenumber:match
-                            // A context line has the format:
-                            // path-linenumber-match
-                            // This regex distinguishes between them by looking for the colon after the line number.
                             return /^(.+?):(\d+):(.*)$/.test(line);
                         }).length;
                     sendData?.({
@@ -84,6 +113,53 @@ export const createGrepTool = (options = {}) => {
         }),
     };
 };
+function likelyUnbalancedRegex(pattern) {
+    const counts = {
+        openParen: 0,
+        closeParen: 0,
+        openBracket: 0,
+        closeBracket: 0,
+        openBrace: 0,
+        closeBrace: 0,
+    };
+    let escaped = false;
+    for (let i = 0; i < pattern.length; i++) {
+        const ch = pattern[i];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (ch === "\\") {
+            escaped = true;
+            continue;
+        }
+        switch (ch) {
+            case "(":
+                counts.openParen++;
+                break;
+            case ")":
+                counts.closeParen++;
+                break;
+            case "[":
+                counts.openBracket++;
+                break;
+            case "]":
+                counts.closeBracket++;
+                break;
+            case "{":
+                counts.openBrace++;
+                break;
+            case "}":
+                counts.closeBrace++;
+                break;
+            default:
+                break;
+        }
+    }
+    return (counts.openParen !== counts.closeParen ||
+        counts.openBracket !== counts.closeBracket ||
+        counts.openBrace !== counts.closeBrace);
+}
 /**
  * Search files for patterns using ripgrep
  *
@@ -92,45 +168,57 @@ export const createGrepTool = (options = {}) => {
  * @param options - Additional options for the grep command
  * @returns The result of the grep command
  */
-function grepFiles(pattern, path, options = {}) {
+export function buildGrepCommand(pattern, path, options = {}) {
+    const effectiveRecursive = options.recursive === null ? true : options.recursive;
+    const effectiveIgnoreCase = options.ignoreCase === null ? false : options.ignoreCase;
+    const effectiveSearchIgnored = options.searchIgnored === null ? false : options.searchIgnored;
+    const effectiveFilePattern = options.filePattern;
+    const effectiveContextLines = options.contextLines;
+    // Determine literal handling: if options.literal is explicitly provided, use it.
+    // If null/undefined, auto-detect unbalanced regexes and prefer fixed-strings.
+    let effectiveLiteral;
+    if (options.literal === true) {
+        effectiveLiteral = true;
+    }
+    else if (options.literal === false) {
+        effectiveLiteral = false;
+    }
+    else {
+        effectiveLiteral = likelyUnbalancedRegex(pattern);
+    }
+    let command = "rg --line-number";
+    if (effectiveRecursive === false) {
+        command += " --max-depth=0";
+    }
+    if (effectiveIgnoreCase) {
+        command += " --ignore-case";
+    }
+    if (effectiveContextLines !== null && effectiveContextLines !== undefined) {
+        command += ` --context=${effectiveContextLines}`;
+    }
+    if (effectiveFilePattern !== null && effectiveFilePattern !== undefined) {
+        command += ` --glob=${JSON.stringify(effectiveFilePattern)}`;
+    }
+    if (effectiveSearchIgnored) {
+        command += " --no-ignore";
+    }
+    if (effectiveLiteral) {
+        command += " -F";
+    }
+    command += ` ${JSON.stringify(pattern)}`;
+    command += ` ${path}`;
+    return command;
+}
+export function grepFiles(pattern, path, options = {}) {
     try {
-        // Handle null values by providing defaults
-        const effectiveRecursive = options.recursive === null ? true : options.recursive;
-        const effectiveIgnoreCase = options.ignoreCase === null ? false : options.ignoreCase;
-        const effectiveSearchIgnored = options.searchIgnored === null ? false : options.searchIgnored;
-        const effectiveFilePattern = options.filePattern;
-        const effectiveContextLines = options.contextLines;
-        // Build the ripgrep command
-        let command = "rg --line-number";
-        // Ripgrep is recursive by default, so we only need to add
-        // --no-recursive if effectiveRecursive is explicitly false
-        if (effectiveRecursive === false) {
-            command += " --max-depth=0";
-        }
-        if (effectiveIgnoreCase) {
-            command += " --ignore-case";
-        }
-        if (effectiveContextLines !== null && effectiveContextLines !== undefined) {
-            command += ` --context=${effectiveContextLines}`;
-        }
-        // Add pattern (escaped for shell)
-        command += ` ${JSON.stringify(pattern)}`;
-        // Add path
-        command += ` ${path}`;
-        // Add file pattern if specified
-        if (effectiveFilePattern !== null && effectiveFilePattern !== undefined) {
-            command += ` --glob=${JSON.stringify(effectiveFilePattern)}`;
-        }
-        if (effectiveSearchIgnored) {
-            command += " --no-ignore";
-        }
-        // Execute the command
+        const command = buildGrepCommand(pattern, path, options);
         const result = execSync(command, { encoding: "utf-8" });
         return result;
     }
     catch (error) {
-        if (error instanceof Error && "status" in error && error.status === 1) {
-            // Status 1 in ripgrep just means "no matches found"
+        if (error instanceof Error &&
+            "status" in error &&
+            error.status === 1) {
             return "No matches found.";
         }
         throw new Error(`Error executing ripgrep: ${error.message}`);

package/dist/tools/index.d.ts

@@ -9,15 +9,6 @@ export declare function initTools({ terminal, tokenCounter, events, autoAcceptAl
     events: Map<string, Message[]>;
     autoAcceptAll: boolean;
 }): Promise<{
-    readonly memoryWrite: import("ai").Tool<{
-        filePath: string;
-        content: string;
-    }, string>;
-    readonly memoryRead: import("ai").Tool<{
-        filePath: string | null;
-    }, string | {
-        content: string;
-    }>;
     readonly webSearch: import("ai").Tool<{
         query: string;
     }, string>;
@@ -40,6 +31,7 @@ export declare function initTools({ terminal, tokenCounter, events, autoAcceptAl
         filePattern: string | null;
         contextLines: number | null;
         searchIgnored: boolean | null;
+        literal: boolean | null;
     }, string>;
     readonly codeInterpreter: import("ai").Tool<{
         code: string;
@@ -80,15 +72,6 @@ export declare function initTools({ terminal, tokenCounter, events, autoAcceptAl
 export declare function initCliTools({ tokenCounter, }: {
     tokenCounter: TokenCounter;
 }): Promise<{
-    readonly memoryWrite: import("ai").Tool<{
-        filePath: string;
-        content: string;
-    }, string>;
-    readonly memoryRead: import("ai").Tool<{
-        filePath: string | null;
-    }, string | {
-        content: string;
-    }>;
     readonly webSearch: import("ai").Tool<{
         query: string;
     }, string>;
@@ -111,6 +94,7 @@ export declare function initCliTools({ tokenCounter, }: {
         filePattern: string | null;
         contextLines: number | null;
         searchIgnored: boolean | null;
+        literal: boolean | null;
     }, string>;
     readonly codeInterpreter: import("ai").Tool<{
         code: string;

package/dist/tools/index.js

@@ -5,8 +5,6 @@ import { createDeleteFileTool } from "./delete-file.js";
 import { createDirectoryTreeTool } from "./directory-tree.js";
 import { createEditFileTool } from "./edit-file.js";
 import { createGrepTool } from "./grep.js";
-import { createMemoryReadTool } from "./memory-read.js";
-import { createMemoryWriteTool } from "./memory-write.js";
 import { createMoveFileTool } from "./move-file.js";
 import { createReadFileTool } from "./read-file.js";
 import { createReadMultipleFilesTool } from "./read-multiple-files.js";
@@ -60,6 +58,8 @@ export async function initTools({ terminal, tokenCounter, events, autoAcceptAll,
     const deleteFileTool = await createDeleteFileTool({
         workingDir: process.cwd(),
         sendData: sendDataFn,
+        terminal,
+        autoAcceptAll,
     });
     const codeInterpreterTool = createCodeInterpreterTool({
         sendData: sendDataFn,
@@ -85,12 +85,6 @@ export async function initTools({ terminal, tokenCounter, events, autoAcceptAll,
         terminal,
         autoAcceptAll,
     });
-    const memoryReadTool = createMemoryReadTool({
-        sendData: sendDataFn,
-    });
-    const memoryWriteTool = createMemoryWriteTool({
-        sendData: sendDataFn,
-    });
     const tools = {
         ...readFileTool,
         ...readMultipleFilesTool,
@@ -105,8 +99,6 @@ export async function initTools({ terminal, tokenCounter, events, autoAcceptAll,
         ...webFetchTool,
         ...bashTool,
         ...webSearchTool,
-        ...memoryReadTool,
-        ...memoryWriteTool,
     };
     return tools;
 }
@@ -144,6 +136,8 @@ export async function initCliTools({ tokenCounter, }) {
     const deleteFileTool = await createDeleteFileTool({
         workingDir: process.cwd(),
         sendData: undefined,
+        terminal: undefined,
+        autoAcceptAll: true,
     });
     const codeInterpreterTool = createCodeInterpreterTool({
         sendData: undefined,
@@ -169,12 +163,6 @@ export async function initCliTools({ tokenCounter, }) {
         terminal: undefined,
         autoAcceptAll: true,
     });
-    const memoryReadTool = createMemoryReadTool({
-        sendData: undefined,
-    });
-    const memoryWriteTool = createMemoryWriteTool({
-        sendData: undefined,
-    });
     const tools = {
         ...readFileTool,
         ...readMultipleFilesTool,
@@ -189,8 +177,6 @@ export async function initCliTools({ tokenCounter, }) {
         ...webFetchTool,
         ...bashTool,
         ...webSearchTool,
-        ...memoryReadTool,
-        ...memoryWriteTool,
     };
     return tools;
 }

package/package.json

@@ -1,11 +1,19 @@
 {
   "name": "@travisennis/acai",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "An AI assistant for developing software.",
   "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "bin": {
-    "acai": "dist/index.js"
+    "acai": "dist/index.js",
+    "@travisennis/acai": "dist/index.js"
   },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
   "keywords": [
     "cli",
     "ai",
@@ -17,12 +25,13 @@
   "license": "MIT",
   "scripts": {
     "build": "tsc --pretty -p tsconfig.build.json",
-    "clean": "rm -rf ./dist/",
+    "clean": "rm -rf ./dist/ ./tsconfig.build.tsbuildinfo",
     "compile": "tsc --pretty -p tsconfig.json",
     "lint": "biome lint",
     "lint:fix": "biome lint --unsafe --write",
     "lint:staged": "biome lint --error-on-warnings --no-errors-on-unmatched --staged",
     "format:staged": "biome check --staged --formatter-enabled=true --linter-enabled=false --no-errors-on-unmatched",
+    "prepack": "npm run clean && npm run build",
     "prepare": "husky",
     "test": "c8 node --no-warnings --test test/**/*.test.ts",
     "pretest": "npm run compile",
@@ -35,48 +44,49 @@
     "typecheck:staged": "tsc --noEmit --pretty -p tsconfig.json"
   },
   "dependencies": {
-    "@ai-sdk/anthropic": "^2.0.2",
-    "@ai-sdk/deepseek": "^1.0.6",
-    "@ai-sdk/google": "^2.0.5",
-    "@ai-sdk/openai": "^2.0.11",
-    "@ai-sdk/openai-compatible": "^1.0.6",
+    "@ai-sdk/anthropic": "^2.0.6",
+    "@ai-sdk/deepseek": "^1.0.11",
+    "@ai-sdk/google": "^2.0.8",
+    "@ai-sdk/openai": "^2.0.20",
+    "@ai-sdk/openai-compatible": "^1.0.11",
     "@crosscopy/clipboard": "^0.2.8",
-    "@inquirer/prompts": "^7.8.1",
-    "@travisennis/stdlib": "^0.0.13",
-    "ai": "^5.0.11",
-    "chalk": "^5.5.0",
+    "@inquirer/prompts": "^7.8.4",
+    "@travisennis/stdlib": "^0.0.14",
+    "ai": "^5.0.23",
+    "chalk": "^5.6.0",
     "cheerio": "^1.1.2",
     "cli-highlight": "^2.1.11",
     "cli-table3": "^0.6.5",
     "diff": "^8.0.2",
     "duck-duck-scrape": "^2.2.7",
-    "exa-js": "^1.8.27",
+    "exa-js": "^1.9.2",
     "globby": "^14.1.0",
     "ignore": "^7.0.5",
     "log-update": "^6.1.0",
-    "marked": "16.1.2",
-    "node-notifier": "^10.0.1",
+    "marked": "16.2.0",
     "ora": "^8.2.0",
-    "p-throttle": "^7.0.0",
-    "pino": "^9.8.0",
+    "p-throttle": "^8.0.0",
+    "pino": "^9.9.0",
     "pino-pretty": "^13.1.1",
     "pino-roll": "^3.1.0",
-    "simple-git": "^3.28.0",
     "tiktoken": "^1.0.22",
     "wrap-ansi": "^9.0.0",
     "zod": "^3.25.75"
   },
   "devDependencies": {
     "@ai-sdk/provider": "^2.0.0",
-    "@biomejs/biome": "2.1.4",
+    "@biomejs/biome": "2.2.2",
     "@commitlint/config-conventional": "^19.8.1",
-    "@types/node": "^24.2.1",
+    "@types/node": "^24.3.0",
     "@types/node-notifier": "^8.0.5",
     "c8": "^10.1.3",
     "commitlint": "^19.8.1",
     "husky": "^9.1.7",
     "typescript": "^5.9.2"
   },
+  "engines": {
+    "node": ">=20"
+  },
   "publishConfig": {
     "access": "public"
   }

package/.acai/acai.json

@@ -1,9 +0,0 @@
-{
-  "logs": {
-    "path": "/Users/travisennis/.acai/logs/current.log"
-  },
-  "tools": {
-    "maxTokens": 30000
-  },
-  "notify": true
-}

package/.acai/prompts/add-openrouter-model.md

@@ -1,13 +0,0 @@
-Your task it to add a new model to the ./source/model/openrouter-provider.ts.
-
-I want you to accomplish this by writing a javascript script and executing it with the code-interpreter tool.
-
-This script should do the following:
-1. fetch `openrouter.ai/api/v1/models` using https
-2. parse the json response. the shape should be `{"data":[]}`
-3. filter the `data` array to find the object whose `id` is `{{INPUT}}`
-4. log the model information found in the object
-
-Take that model information and use it to add a new model to openrouter-provider.ts. Follow the pattern that exists to add a new model. If any information is missing ask the user to provide guidance.
-
-Create a new git branch before making any edits.

package/.acai/prompts/project-status.md

@@ -1,4 +0,0 @@
-Summarize the current git status of this project.
-
-Status:
-!`git status`

package/.acai/prompts/update-architecture-document.md

@@ -1,9 +0,0 @@
-Manage the ./ARCHITECTURE.md document for this project. If file doesn't exist create it. If it does exist make sure it is up-to-date and reflects the current state of the project.
-
-The main header of the document should be Acai Architecture.
-
-Include a Project Structure that is the current directory tree for the entire project.
-
-Next, there should be section called File Descriptions that should include a list of every file in the project and a brief description of what each is and does.
-
-Finally, a section called Flow Diagram should document with mermaid diagrams the primary flows in the application, starting with the entry points defined in the package.json. 

package/.acai/rules/learned-rules.md

@@ -1,9 +0,0 @@
-- Always adhere to existing code patterns and project conventions when generating code.
-- Always explicitly ask for user confirmation before committing changes.
-- Always replace usages console.log with usages of console.info.
-- Always run a build after making code changes to verify correctness.
-- Always use the most efficient workflow to complete tasks.
-- Always stage changes before attempting to commit them.
-- Never amend git commits without approval from the user.
-- Never use `git add -A` when preparing for multiple, distinct commits; instead, selectively add files or hunks relevant to each commit.
-- Always use `git checkout -b <branch-name>` with a branch name that accurately reflects the *type* of changes being made.

package/.ai/docs/available-tools.txt

@@ -1,3 +0,0 @@
-Available tools:
-
-bashTool