@travisennis/acai 0.0.1

package/source/config.ts

@@ -0,0 +1,223 @@
+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

@@ -0,0 +1,115 @@
+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
+}

package/source/dedent.ts

@@ -0,0 +1,53 @@
+type Dedent = (strings: TemplateStringsArray, ...values: unknown[]) => string;
+
+const spaces = /^(\s+)\S+/;
+
+export const dedent: Dedent = (
+  strings: TemplateStringsArray,
+  ...values: unknown[]
+): string => {
+  // Perform interpolation
+  let result = "";
+  for (let i = 0; i < strings.raw.length; i++) {
+    const next =
+      strings.raw[i] ??
+      ""
+        // handle escaped newlines, backticks, and interpolation characters
+        .replace(/\\\n[ \t]*/g, "")
+        .replace(/\\`/g, "`")
+        .replace(/\\\$/g, "$")
+        .replace(/\\\{/g, "{");
+
+    result += next;
+
+    if (i < values.length) {
+      result += values[i];
+    }
+  }
+
+  // Strip indentation
+  const lines = result.split("\n");
+  let mindent: null | number = null;
+
+  for (const line of lines) {
+    const m = line.match(spaces);
+    if (m) {
+      const indent = m[1]?.length ?? 0;
+      mindent = mindent === null ? indent : Math.min(mindent, indent);
+    }
+  }
+
+  if (mindent !== null) {
+    result = lines
+      .map((l) => (l[0] === " " || l[0] === "\t" ? l.slice(mindent) : l))
+      .join("\n");
+  }
+
+  // Trim leading and trailing whitespace
+  result = result.trim();
+
+  // Handle escaped newlines at the end
+  result = result.replace(/\\n/g, "\n");
+
+  return result;
+};

package/source/formatting.ts

@@ -0,0 +1,132 @@
+import path from "node:path";
+
+const MD_CODE_BLOCK = /```(?:[\w-]+)?\n(.*?)```/s;
+
+/**
+ * Extracts the first code block content from the given text.
+ * If a Markdown-style triple backtick code block is found, returns its inner content.
+ * Otherwise, returns the original text unchanged.
+ *
+ * @param text - The input string potentially containing a Markdown code block.
+ * @returns The extracted code inside the first code block, or the original text if no block is found.
+ */
+export const extractCodeBlock = (text: string): string => {
+  const pattern = MD_CODE_BLOCK;
+  const match = text.match(pattern);
+  if (match) {
+    return match[1] ?? "";
+  }
+  return text;
+};
+
+export function extractXml(text: string, tag: string): string {
+  const match = text.match(new RegExp(`<${tag}>(.*?)</${tag}>`, "s"));
+  return match ? (match[1] ?? "") : "";
+}
+
+export function removeAllLineBreaks(text: string) {
+  return text.replace(/(\r\n|\n|\r)/gm, " ");
+}
+
+export function removeHtmlTags(text: string) {
+  return text.replace(/<[^>]*>?/gm, "");
+}
+
+const MD_TRIPLE_QUOTE = "```";
+
+export type FormatType = "xml" | "markdown" | "bracket";
+
+const codeBlockExtensions: Record<string, string> = {
+  js: "javascript",
+  ts: "typescript",
+  py: "python",
+  rb: "ruby",
+  java: "java",
+  cpp: "cpp",
+  cs: "csharp",
+  go: "go",
+  rs: "rust",
+  php: "php",
+  html: "html",
+  css: "css",
+  json: "json",
+  yml: "yaml",
+  yaml: "yaml",
+  md: "markdown",
+  sql: "sql",
+  sh: "bash",
+  bash: "bash",
+  txt: "text",
+};
+
+export function formatFile(
+  file: string,
+  content: string,
+  format: FormatType,
+): string {
+  const fileExtension = path.extname(file).slice(1);
+  const codeBlockName = codeBlockExtensions[fileExtension] || fileExtension;
+  switch (format) {
+    case "xml":
+      return `<file>\n<name>${file}</name>\n<content>\n${content}\n</content>\n</file>`;
+    case "markdown":
+      return `## File: ${file}\n${MD_TRIPLE_QUOTE} ${codeBlockName}\n${content}\n${MD_TRIPLE_QUOTE}`;
+    case "bracket":
+      return `[file name]: ${file}\n[file content begin]\n${content}\n[file content end]`;
+    default:
+      throw new Error(`Unsupported format: ${format}`);
+  }
+}
+
+export function formatUrl(
+  siteUrl: string,
+  content: string,
+  format: FormatType,
+): string {
+  switch (format) {
+    case "xml":
+      return `<webpage>\n<url>${siteUrl}</url>\n<content>\n${content}\n</content>\n</webpage>`;
+    case "markdown":
+      return `## URL: ${siteUrl}\n${MD_TRIPLE_QUOTE}\n${content}\n${MD_TRIPLE_QUOTE}`;
+    case "bracket":
+      return `[url]: ${siteUrl}\n[url content begin]\n${content}\n[url content end]`;
+    default:
+      throw new Error(`Unsupported format: ${format}`);
+  }
+}
+
+export function formatCodeSnippet(
+  file: string,
+  content: string,
+  format: FormatType,
+) {
+  const fileExtension = path.extname(file).slice(1);
+  const codeBlockName = codeBlockExtensions[fileExtension] || fileExtension;
+  switch (format) {
+    case "xml":
+      return `<code>\n${content}\n</code>`;
+    case "markdown":
+      return `${MD_TRIPLE_QUOTE} ${codeBlockName}\n${content}\n${MD_TRIPLE_QUOTE}`;
+    case "bracket":
+      return `[code begin]\n${content}\n[code end]`;
+    default:
+      throw new Error(`Unsupported format: ${format}`);
+  }
+}
+
+export function formatBlock(
+  content: string,
+  blockName: string,
+  format: FormatType,
+): string {
+  switch (format) {
+    case "xml":
+      return `<${blockName}>\n${content}\n</${blockName}>\n</file>`;
+    case "markdown":
+      return `## ${blockName}\n${MD_TRIPLE_QUOTE}\n${content}\n${MD_TRIPLE_QUOTE}`;
+    case "bracket":
+      return `[${blockName} begin]\n${content}\n[${blockName} end]`;
+    default:
+      throw new Error(`Unsupported format: ${format}`);
+  }
+}