@travisennis/acai 0.0.1 → 0.0.3

package/source/commands/prompt-command.ts

@@ -1,150 +0,0 @@
-import { readdir, readFile } from "node:fs/promises";
-import path, { basename } from "node:path";
-import { processPrompt } from "../mentions.ts";
-import type { CommandOptions, ReplCommand } from "./types.ts";
-
-export const promptCommand = ({
-  terminal,
-  modelManager,
-  promptManager,
-  config,
-}: CommandOptions): ReplCommand => {
-  return {
-    command: "/prompt",
-    description:
-      "Loads and executes prompts. Project prompts override user prompts with the same name.",
-    result: "use" as const,
-    getSubCommands: async (): Promise<string[]> => {
-      const getPromptNamesFromDir = async (
-        dirPath: string,
-      ): Promise<string[]> => {
-        try {
-          const dirents = await readdir(dirPath, { withFileTypes: true });
-          return dirents
-            .filter((dirent) => dirent.isFile() && dirent.name.endsWith(".md"))
-            .map((dirent) => basename(dirent.name, ".md"));
-        } catch (error) {
-          if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-            return []; // Directory doesn't exist, return empty array
-          }
-          terminal.error(`Error reading prompts from ${dirPath}: ${error}`);
-          return []; // Return empty on other errors too, but log them
-        }
-      };
-
-      const userPromptDir = config.app.ensurePathSync("prompts"); // User prompts are global (~/.acai/prompts)
-      const projectPromptDir = config.project.ensurePathSync("prompts"); // Project prompts are local (./.acai/prompts)
-
-      const userPrompts = await getPromptNamesFromDir(userPromptDir);
-      const projectPrompts = await getPromptNamesFromDir(projectPromptDir);
-
-      // Combine and deduplicate, with project prompts taking precedence
-      const allPrompts = new Set([...userPrompts, ...projectPrompts]);
-      return Array.from(allPrompts).sort();
-    },
-    execute: async (args: string[]) => {
-      const promptName = args?.[0];
-      if (!promptName) {
-        terminal.warn(
-          "Please provide a prompt name. Usage: /prompt <prompt-name> [input...]",
-        );
-        return;
-      }
-
-      // Check for old format and provide helpful error
-      if (promptName.includes(":")) {
-        terminal.warn(
-          "The old format (user:name or project:name) is no longer supported. Use: /prompt <prompt-name> [input...]",
-        );
-        return;
-      }
-
-      try {
-        const promptResult = await findPrompt(promptName, config);
-
-        if (!promptResult) {
-          terminal.error(
-            `Prompt not found: ${promptName}. Available prompts can be seen with tab completion.`,
-          );
-          return;
-        }
-
-        let promptContent: string;
-        try {
-          promptContent = await readFile(promptResult.path, "utf8");
-        } catch (error) {
-          if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-            terminal.error(
-              `Prompt file not found: ${promptName} at ${promptResult.path}`,
-            );
-            return;
-          }
-          throw error;
-        }
-
-        // Combine remaining arguments into a single string for input
-        const inputArgs = args.slice(1);
-        const inputString = inputArgs.join(" ");
-
-        // Replace {{INPUT}} placeholder with the input string
-        if (promptContent.includes("{{INPUT}}")) {
-          promptContent = promptContent.replace(/{{INPUT}}/g, inputString);
-        }
-
-        terminal.info(`Loaded ${promptResult.type} prompt: ${promptName}`);
-        if (inputArgs.length > 0) {
-          terminal.info(`Input: "${inputString}"`);
-        }
-
-        const processedPrompt = await processPrompt(promptContent, {
-          baseDir: process.cwd(),
-          model: modelManager.getModelMetadata("repl"),
-        });
-
-        for (const context of processedPrompt.context) {
-          promptManager.addContext(context);
-        }
-        promptManager.set(processedPrompt.message);
-      } catch (error) {
-        terminal.error(`Error loading prompt: ${(error as Error).message}`);
-      }
-    },
-  };
-};
-
-async function findPrompt(
-  promptName: string,
-  config: CommandOptions["config"],
-): Promise<{ path: string; type: "project" | "user" } | null> {
-  // Check project prompts first (they take precedence)
-  const projectPath = path.join(
-    config.project.ensurePathSync("prompts"),
-    `${promptName}.md`,
-  );
-
-  try {
-    await readFile(projectPath, "utf8");
-    return { path: projectPath, type: "project" };
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
-      throw error; // Re-throw non-file-not-found errors
-    }
-  }
-
-  // Check user prompts if not found in project
-  const userPath = path.join(
-    config.app.ensurePathSync("prompts"),
-    `${promptName}.md`,
-  );
-
-  try {
-    await readFile(userPath, "utf8");
-    return { path: userPath, type: "user" };
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
-      throw error; // Re-throw non-file-not-found errors
-    }
-  }
-
-  return null; // Prompt not found in either location
-}

package/source/commands/reset-command.ts

@@ -1,22 +0,0 @@
-import type { CommandOptions, ReplCommand } from "./types.ts";
-
-export const resetCommand = ({
-  terminal,
-  messageHistory,
-}: CommandOptions): ReplCommand => {
-  return {
-    command: "/reset",
-    description: "Saves the chat history and then resets it.",
-    result: "continue" as const,
-    getSubCommands: () => Promise.resolve([]),
-    execute: async () => {
-      if (!messageHistory.isEmpty()) {
-        await messageHistory.save();
-        messageHistory.clear();
-      }
-      terminal.setTitle(`acai: ${process.cwd()}`);
-
-      terminal.clear();
-    },
-  };
-};

package/source/commands/rules-command.ts

@@ -1,76 +0,0 @@
-import { editor } from "@inquirer/prompts";
-import { config } from "../config.ts";
-import type { CommandOptions, ReplCommand } from "./types.ts";
-
-export const rulesCommand = ({ terminal }: CommandOptions): ReplCommand => {
-  return {
-    command: "/rules",
-    description:
-      "View, add, or edit rules. Usage: /rules [view|add <text>|edit]",
-    result: "continue" as const,
-    getSubCommands: () => Promise.resolve(["view", "add", "edit"]),
-    execute: async (args: string[]) => {
-      const subCommand = args[0] ?? "view"; // Default to 'view'
-      const commandArgs = args.slice(1).join(" ");
-
-      try {
-        switch (subCommand) {
-          case "view": {
-            const currentContent = await config.readAgentsFile();
-            if (currentContent) {
-              terminal.writeln("--- Current Rules ---");
-              terminal.writeln(currentContent);
-              terminal.writeln("---------------------");
-            } else {
-              terminal.writeln(
-                "No rules defined yet. Use '/rules add' or '/rules edit'.",
-              );
-            }
-            break;
-          }
-
-          case "add": {
-            const newMemory = commandArgs.trim();
-            if (!newMemory) {
-              terminal.error("Error: Memory text cannot be empty for 'add'.");
-              terminal.writeln("Usage: /memory add <new memory text>");
-              return;
-            }
-            const currentContent = await config.readAgentsFile();
-            const updatedContent = currentContent
-              ? `${currentContent.trim()}\n- ${newMemory}` // Ensure space after dash
-              : `- ${newMemory}`; // Start with dash if new file
-            await config.writeAgentsFile(updatedContent);
-            break;
-          }
-
-          case "edit": {
-            const currentContent = await config.readAgentsFile();
-            const updatedContent = await editor({
-              message: "Edit rules:",
-              postfix: "md",
-              default: currentContent,
-            });
-            // Check if the user cancelled the edit (editor returns the original content)
-            // Or if the content is actually different
-            if (updatedContent !== currentContent) {
-              await config.writeAgentsFile(updatedContent);
-            } else {
-              terminal.writeln("Edit cancelled or no changes made.");
-            }
-            break;
-          }
-
-          default:
-            terminal.writeln(
-              "Invalid subcommand. Usage: /rules [view|add <text>|edit]",
-            );
-            break;
-        }
-      } catch (_error) {
-        // Errors from read/write helpers are already logged
-        terminal.error("Failed to execute memory command.");
-      }
-    },
-  };
-};

package/source/commands/save-command.ts

@@ -1,20 +0,0 @@
-import type { CommandOptions, ReplCommand } from "./types.ts";
-
-export const saveCommand = ({
-  messageHistory,
-  terminal,
-}: CommandOptions): ReplCommand => {
-  return {
-    command: "/save",
-    description: "Saves the chat history.",
-    result: "continue" as const,
-    getSubCommands: () => Promise.resolve([]),
-    execute: async () => {
-      if (!messageHistory.isEmpty()) {
-        await messageHistory.save();
-      }
-
-      terminal.info("Message history saved.");
-    },
-  };
-};

package/source/commands/types.ts

@@ -1,28 +0,0 @@
-import type { ConfigManager } from "../config.ts";
-import type { MessageHistory } from "../messages.ts";
-import type { ModelManager } from "../models/manager.ts";
-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";
-
-export interface ReplCommand {
-  command: string;
-  aliases?: string[];
-  description: string;
-  result: "break" | "continue" | "use";
-  getSubCommands: () => Promise<string[]>;
-  execute: (args: string[]) => Promise<void>;
-}
-
-export interface CommandOptions {
-  promptManager: PromptManager;
-  modelManager: ModelManager;
-  terminal: Terminal;
-  messageHistory: MessageHistory;
-  tokenTracker: TokenTracker;
-  config: ConfigManager;
-  tokenCounter: TokenCounter;
-  toolEvents: Map<string, Message[]>;
-}

package/source/commands/usage-command.ts

@@ -1,26 +0,0 @@
-import type { CommandOptions, ReplCommand } from "./types.ts";
-
-export function usageCommand({
-  terminal,
-  tokenTracker,
-}: CommandOptions): ReplCommand {
-  return {
-    command: "/usage",
-    description: "Show token usage breakdown",
-    result: "continue",
-    getSubCommands: () => Promise.resolve([]),
-    execute() {
-      const entries = Object.entries(tokenTracker.getUsageBreakdown());
-      if (entries.length === 0) {
-        terminal.info("No usage yet.");
-      } else {
-        terminal.table(entries, {
-          header: ["App", "Tokens"],
-          colWidths: [30, 70],
-        });
-      }
-
-      return Promise.resolve();
-    },
-  };
-}

package/source/config.ts

@@ -1,223 +0,0 @@
-import { mkdirSync } from "node:fs";
-import fs from "node:fs/promises";
-import { homedir } from "node:os";
-import path from "node:path";
-import { z } from "zod";
-import { jsonParser } from "./parsing.ts";
-
-export class DirectoryProvider {
-  private baseDir: string;
-
-  constructor(baseDir: string) {
-    this.baseDir = baseDir;
-  }
-
-  getPath(subdir?: string): string {
-    return subdir ? path.join(this.baseDir, subdir) : this.baseDir;
-  }
-
-  // Async-by-default: prefer non-blocking filesystem operations.
-  async ensurePath(subdir?: string): Promise<string> {
-    const dirPath = this.getPath(subdir);
-    await fs.mkdir(dirPath, { recursive: true });
-    return dirPath;
-  }
-
-  // Synchronous helper for call-sites that require immediate directory availability.
-  ensurePathSync(subdir?: string): string {
-    const dirPath = this.getPath(subdir);
-    mkdirSync(dirPath, { recursive: true });
-    return dirPath;
-  }
-}
-
-export class ConfigManager {
-  readonly project: DirectoryProvider;
-  readonly app: DirectoryProvider;
-
-  constructor() {
-    this.project = new DirectoryProvider(path.join(process.cwd(), ".acai"));
-    this.app = new DirectoryProvider(path.join(homedir(), ".acai"));
-  }
-
-  private async _readConfig(
-    configPath: string,
-  ): Promise<Partial<ProjectConfig>> {
-    try {
-      const data = await fs.readFile(configPath, "utf8");
-      return jsonParser(ProjectConfigSchema).parse(data);
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-        return {};
-      }
-      throw error;
-    }
-  }
-
-  // Project config helpers
-  async readProjectConfig(): Promise<ProjectConfig> {
-    const appConfigPath = path.join(this.app.getPath(), "acai.json");
-    const projectConfigPath = path.join(this.project.getPath(), "acai.json");
-
-    const appConfig = await this._readConfig(appConfigPath);
-    const projectConfig = await this._readConfig(projectConfigPath);
-
-    const mergedConfig = {
-      ...appConfig,
-      ...projectConfig,
-    };
-
-    return ProjectConfigSchema.parse(mergedConfig);
-  }
-
-  async readAgentsFile(): Promise<string> {
-    const agentsPath = path.join(process.cwd(), "AGENTS.md");
-    try {
-      return await fs.readFile(agentsPath, "utf8");
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-        return "";
-      }
-      throw error;
-    }
-  }
-
-  async writeAgentsFile(rules: string): Promise<void> {
-    const agentsPath = path.join(process.cwd(), "AGENTS.md");
-    try {
-      return await fs.writeFile(agentsPath, rules, "utf8");
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-        return;
-      }
-      throw error;
-    }
-  }
-  // Project-specific learned rules
-  async readProjectLearnedRulesFile(): Promise<string> {
-    const rulesPath = path.join(
-      this.project.getPath("rules"),
-      "learned-rules.md",
-    );
-    try {
-      return await fs.readFile(rulesPath, "utf8");
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-        return "";
-      }
-      throw error;
-    }
-  }
-
-  async writeProjectLearnedRulesFile(rules: string): Promise<void> {
-    const rulesDir = await this.project.ensurePath("rules");
-    const rulesPath = path.join(rulesDir, "learned-rules.md");
-    try {
-      return await fs.writeFile(rulesPath, rules, "utf8");
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-        return;
-      }
-      throw error;
-    }
-  }
-
-  // App-cached learned rules (used during conversation analysis)
-  async readCachedLearnedRulesFile(): Promise<string> {
-    const rulesPath = path.join(this.app.getPath("rules"), "learned-rules.md");
-    try {
-      return await fs.readFile(rulesPath, "utf8");
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-        return "";
-      }
-      throw error;
-    }
-  }
-
-  async writeCachedLearnedRulesFile(rules: string): Promise<void> {
-    const rulesDir = await this.app.ensurePath("rules");
-    const rulesPath = path.join(rulesDir, "learned-rules.md");
-    try {
-      return await fs.writeFile(rulesPath, rules, "utf8");
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-        return;
-      }
-      throw error;
-    }
-  }
-
-  // App config helpers
-  async readAppConfig(
-    configName: string,
-  ): Promise<Record<PropertyKey, unknown>> {
-    const configPath = path.join(this.app.getPath(), `${configName}.json`);
-    try {
-      const data = await fs.readFile(configPath, "utf8");
-      return JSON.parse(data);
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-        return {};
-      }
-      throw error;
-    }
-  }
-
-  async ensureAppConfig(
-    configName: string,
-  ): Promise<Record<PropertyKey, unknown>> {
-    const configPath = path.join(this.app.getPath(), `${configName}.json`);
-
-    try {
-      await fs.access(configPath);
-      return await this.readAppConfig(configName);
-    } catch {
-      // Create directory and default config if missing
-      await this.app.ensurePath();
-
-      const defaultConfig = {
-        logs: {
-          path: path.join(this.app.getPath(), "logs", "current.log"),
-        },
-        tools: {
-          maxTokens: 30000,
-        },
-        notify: true,
-      };
-
-      await fs.writeFile(configPath, JSON.stringify(defaultConfig, null, 2));
-      return defaultConfig;
-    }
-  }
-
-  async writeAppConfig(
-    configName: string,
-    data: Record<PropertyKey, unknown>,
-  ): Promise<void> {
-    await this.app.ensurePath();
-    const configPath = path.join(this.app.getPath(), `${configName}.json`);
-    await fs.writeFile(configPath, JSON.stringify(data, null, 2));
-  }
-}
-
-// Type definitions
-const ProjectConfigSchema = z.object({
-  logs: z
-    .object({
-      path: z.string(),
-    })
-    .optional(),
-  tools: z
-    .object({
-      maxTokens: z.number().default(30000),
-    })
-    .optional()
-    .default({ maxTokens: 30000 }),
-  notify: z.boolean().optional().default(true),
-});
-
-export type ProjectConfig = z.infer<typeof ProjectConfigSchema>;
-
-// Create a singleton instance
-export const config = new ConfigManager();

package/source/conversation-analyzer.ts

@@ -1,115 +0,0 @@
-import { generateText, type ModelMessage } from "ai";
-import { config } from "./config.ts";
-import { createUserMessage } from "./messages.ts";
-import type { ModelManager } from "./models/manager.ts";
-import { systemPrompt } from "./prompts.ts";
-import type { Terminal } from "./terminal/index.ts";
-import type { TokenTracker } from "./token-tracker.ts";
-
-// Modified System Prompt
-const system =
-  async () => `You are an expert analyst reviewing conversations between a coding agent and a software engineer. Your goal is to identify instances where the engineer corrected the agent's approach or understanding in a way that reveals a *generalizable principle* for improving the agent's future behavior across *different* tasks.
-
-**Your Task:**
-1. Analyze the conversation provided.
-2. Identify significant corrections or redirections from the engineer. Ignore minor clarifications or task-specific adjustments.
-3. For each significant correction, infer a *single, concise, broadly applicable, actionable rule* (starting with 'Always' or 'Never') that captures the underlying principle the agent should follow in the future.
-4. Ensure the rule is general enough to be useful in various scenarios, not just the specific context of this conversation.
-5. Provide a brief, illustrative quote or example from the conversation in parentheses after the rule.
-6. List only the inferred rules in Markdown bullet points. Do not include explanations, summaries, or conversational filler.
-
-**Crucially, AVOID generating rules that are:**
-- Overly specific to the files, functions, or variables discussed (e.g., "Always check for null in the 'processUserData' function"). Instead, generalize (e.g., "Always validate data from external sources before processing").
-- Merely restatements of the task requirements.
-- Too narrow to be useful outside the immediate context.
-- Related to minor typos or formatting preferences unless they represent a consistent pattern requested by the user.
-
-**Good General Rule Examples:**
-<examples>
-- Always ask for clarification if the user's request is ambiguous.
-- Never make assumptions about file paths without confirmation.
-- Always follow the user's explicitly stated formatting preferences.
-- Never provide incomplete code snippets without indicating they are partial.
-- Always check for potential null or undefined values before accessing properties.
-</examples>
-
-**Bad Specific Rule Examples (Avoid These):**
-<bad-examples>
-- Always use 'const' instead of 'let' for the 'userId' variable in 'auth.ts'.
-- Never forget to pass the 'config' object to the 'initializeDb' function.
-- Always add a try-catch block around the 'api.fetchData()' call in 'dataService.ts'.
-</bad-examples>
-
-This is the original system prompt the agent operated under:
-<systemPrompt>
-${await systemPrompt()}
-</systemPrompt>`;
-
-export async function analyzeConversation({
-  modelManager,
-  messages,
-  tokenTracker,
-}: {
-  modelManager: ModelManager;
-  messages: ModelMessage[];
-  terminal?: Terminal | undefined;
-  tokenTracker: TokenTracker;
-}): Promise<string[]> {
-  const learnedRules = await config.readCachedLearnedRulesFile();
-  // Modified User Message within analyzeConversation
-  messages.push(
-    createUserMessage([
-      `Analyze this conversation based on the system instructions. Identify points where the user made significant corrections revealing general principles for agent improvement. Infer concise, broadly applicable rules (Always/Never) based *only* on these corrections.
-
-**Key Requirements:**
-- Focus on *generalizable* rules applicable to future, different tasks.
-- Avoid rules tied to the specifics of *this* conversation.
-- Ensure rules don't already exist in <existing-rules>.
-- If no *new, general* rules can be inferred, return an empty list or response.
-- Return *only* the Markdown list of rules, with no preamble or explanation.
-
-<existing-rules>
-${learnedRules}
-</existing-rules>`,
-    ]),
-  );
-  const { text, usage } = await generateText({
-    model: modelManager.getModel("conversation-analyzer"),
-    maxOutputTokens: 8192,
-    system: await system(),
-    messages: messages,
-  });
-
-  tokenTracker.trackUsage("conversation-analyzer", usage);
-
-  // Trim whitespace and check if the response is effectively empty or just whitespace
-  const potentialRulesText = text.trim();
-
-  // Basic check to prevent adding empty lines or just formatting
-  if (!potentialRulesText || potentialRulesText.length === 0) {
-    return []; // Return empty array if no valid rules generated
-  }
-
-  // Split into individual rules, filter out empty lines
-  const potentialRulesList = potentialRulesText
-    .split("\n")
-    .map((rule) => rule.trim())
-    .filter((rule) => rule.length > 0);
-
-  if (potentialRulesList.length === 0) {
-    return []; // Return empty array if splitting results in no rules
-  }
-
-  // Further validation could be added here (e.g., check if it starts with '- ', etc.)
-  // before writing to the file.
-
-  // Append only if there are non-empty potential rules
-  const updatedRules =
-    learnedRules.endsWith("\n") || learnedRules.length === 0
-      ? `${learnedRules}${potentialRulesList.join("\n")}`
-      : `${learnedRules}\n${potentialRulesList.join("\n")}`;
-
-  await config.writeCachedLearnedRulesFile(updatedRules);
-
-  return potentialRulesList; // Return the list of rules that were added
-}