@travisennis/acai 0.0.1

package/dist/source/conversation-analyzer.d.ts

@@ -0,0 +1,10 @@
+import { type ModelMessage } from "ai";
+import type { ModelManager } from "./models/manager.ts";
+import type { Terminal } from "./terminal/index.ts";
+import type { TokenTracker } from "./token-tracker.ts";
+export declare function analyzeConversation({ modelManager, messages, tokenTracker, }: {
+    modelManager: ModelManager;
+    messages: ModelMessage[];
+    terminal?: Terminal | undefined;
+    tokenTracker: TokenTracker;
+}): Promise<string[]>;

package/dist/source/conversation-analyzer.js

@@ -0,0 +1,88 @@
+import { generateText } from "ai";
+import { config } from "./config.js";
+import { createUserMessage } from "./messages.js";
+import { systemPrompt } from "./prompts.js";
+// 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, }) {
+    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/dist/source/dedent.d.ts

@@ -0,0 +1,3 @@
+type Dedent = (strings: TemplateStringsArray, ...values: unknown[]) => string;
+export declare const dedent: Dedent;
+export {};

package/dist/source/dedent.js

@@ -0,0 +1,38 @@
+const spaces = /^(\s+)\S+/;
+export const dedent = (strings, ...values) => {
+    // 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;
+    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/dist/source/formatting.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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 declare const extractCodeBlock: (text: string) => string;
+export declare function extractXml(text: string, tag: string): string;
+export declare function removeAllLineBreaks(text: string): string;
+export declare function removeHtmlTags(text: string): string;
+export type FormatType = "xml" | "markdown" | "bracket";
+export declare function formatFile(file: string, content: string, format: FormatType): string;
+export declare function formatUrl(siteUrl: string, content: string, format: FormatType): string;
+export declare function formatCodeSnippet(file: string, content: string, format: FormatType): string;
+export declare function formatBlock(content: string, blockName: string, format: FormatType): string;

package/dist/source/formatting.js

@@ -0,0 +1,103 @@
+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) => {
+    const pattern = MD_CODE_BLOCK;
+    const match = text.match(pattern);
+    if (match) {
+        return match[1] ?? "";
+    }
+    return text;
+};
+export function extractXml(text, tag) {
+    const match = text.match(new RegExp(`<${tag}>(.*?)</${tag}>`, "s"));
+    return match ? (match[1] ?? "") : "";
+}
+export function removeAllLineBreaks(text) {
+    return text.replace(/(\r\n|\n|\r)/gm, " ");
+}
+export function removeHtmlTags(text) {
+    return text.replace(/<[^>]*>?/gm, "");
+}
+const MD_TRIPLE_QUOTE = "```";
+const codeBlockExtensions = {
+    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, content, format) {
+    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, content, format) {
+    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, content, format) {
+    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, blockName, format) {
+    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}`);
+    }
+}

package/dist/source/index.d.ts

@@ -0,0 +1,18 @@
+declare const flags: {
+    model?: string | undefined;
+    prompt?: string | undefined;
+    oneshot: boolean;
+    continue: boolean;
+    resume: boolean;
+    autoAcceptAll: boolean;
+    help?: boolean | undefined;
+    version?: boolean | undefined;
+};
+/**
+ * Global error handler function.
+ * @param {Error} error - The error to be handled.
+ * @throws {Error} Rethrows the error after logging it.
+ */
+export declare function handleError(error: Error): void;
+export type Flags = typeof flags;
+export {};

package/dist/source/index.js

@@ -0,0 +1,213 @@
+import { text } from "node:stream/consumers";
+import { parseArgs } from "node:util";
+import { select } from "@inquirer/prompts";
+import { asyncTry } from "@travisennis/stdlib/try";
+import { isDefined } from "@travisennis/stdlib/typeguards";
+import { Cli } from "./cli.js";
+import { CommandManager } from "./commands/manager.js";
+import { config } from "./config.js";
+import { logger } from "./logger.js";
+import { MessageHistory } from "./messages.js";
+import { ModelManager } from "./models/manager.js";
+import { isSupportedModel } from "./models/providers.js";
+import { PromptManager } from "./prompts/manager.js";
+import { Repl } from "./repl.js";
+import { initTerminal } from "./terminal/index.js";
+import { TokenTracker } from "./token-tracker.js";
+import { TokenCounter } from "./token-utils.js";
+import { getPackageVersion } from "./version.js";
+const helpText = `
+Usage
+  $ acai <input>
+
+Options
+  --model, -m        Sets the model to use
+  --prompt, -p       Sets the prompt
+  --oneshot, -o      Run once and exit
+  --continue         Load the most recent conversation
+  --resume           Select a recent conversation to resume
+  --autoAcceptAll    Accept all commands and edits without prompting
+  --help, -h         Show help
+  --version, -v      Show version
+
+Examples
+  $ acai --model anthopric:sonnet
+  $ acai -p "initial prompt"
+  $ acai -p "one-shot prompt" -o
+`;
+const parsed = parseArgs({
+    options: {
+        model: { type: "string", short: "m" },
+        prompt: { type: "string", short: "p" },
+        oneshot: { type: "boolean", short: "o", default: false },
+        continue: { type: "boolean", default: false },
+        resume: { type: "boolean", default: false },
+        autoAcceptAll: { type: "boolean", default: false },
+        help: { type: "boolean", short: "h" },
+        version: { type: "boolean", short: "v" },
+    },
+    allowPositionals: true,
+});
+const flags = parsed.values;
+const input = parsed.positionals;
+/**
+ * Global error handler function.
+ * @param {Error} error - The error to be handled.
+ * @throws {Error} Rethrows the error after logging it.
+ */
+export function handleError(error) {
+    logger.error({ error: error }, error.message);
+}
+async function main() {
+    const appConfig = await config.ensureAppConfig("acai");
+    if (flags.version === true) {
+        console.info(getPackageVersion());
+        process.exit(0);
+    }
+    if (flags.help === true) {
+        console.info(helpText);
+        process.exit(0);
+    }
+    const appDir = config.app;
+    const messageHistoryDir = await appDir.ensurePath("message-history");
+    // --- Argument Validation ---
+    if (flags.continue === true && flags.resume === true) {
+        console.error("Cannot use --continue and --resume flags together.");
+        process.exit(1);
+    }
+    const hasContinueOrResume = flags.continue === true || flags.resume === true;
+    if (hasContinueOrResume && flags.oneshot === true) {
+        console.error("Cannot use --continue or --resume with --oneshot.");
+        process.exit(1);
+    }
+    // --- Determine Initial Prompt (potential conflict) ---
+    const positionalPrompt = input.at(0);
+    let stdInPrompt;
+    // Check if there's data available on stdin
+    if (!process.stdin.isTTY) {
+        try {
+            // Non-TTY stdin means data is being piped in
+            stdInPrompt = await text(process.stdin);
+        }
+        catch (error) {
+            console.error(`Error reading stdin: ${error.message}`);
+        }
+    }
+    const initialPromptInput = typeof flags.prompt === "string" && flags.prompt.length > 0
+        ? flags.prompt
+        : positionalPrompt && positionalPrompt.length > 0
+            ? positionalPrompt
+            : undefined;
+    if (hasContinueOrResume && isDefined(initialPromptInput)) {
+        console.error("Cannot use --continue or --resume with an initial prompt.");
+        process.exit(1);
+    }
+    const terminal = initTerminal();
+    terminal.setTitle(`acai: ${process.cwd()}`);
+    const chosenModel = isSupportedModel(flags.model)
+        ? flags.model
+        : "openrouter:sonnet4";
+    const modelManager = new ModelManager({
+        stateDir: await appDir.ensurePath("audit"),
+    });
+    modelManager.setModel("repl", chosenModel);
+    modelManager.setModel("cli", chosenModel);
+    modelManager.setModel("title-conversation", "openrouter:gemini-flash25");
+    modelManager.setModel("conversation-summarizer", "openrouter:gemini-flash25");
+    modelManager.setModel("tool-repair", "openai:gpt-4.1");
+    modelManager.setModel("conversation-analyzer", "openrouter:gemini-flash25");
+    modelManager.setModel("init-project", chosenModel);
+    modelManager.setModel("task-agent", "openrouter:gemini-flash25");
+    const tokenTracker = new TokenTracker();
+    const tokenCounter = new TokenCounter();
+    const messageHistory = new MessageHistory({
+        stateDir: messageHistoryDir,
+        modelManager,
+        tokenTracker,
+    });
+    messageHistory.on("update-title", (title) => terminal.setTitle(title));
+    if (flags.continue === true) {
+        const histories = await MessageHistory.load(messageHistoryDir, 1);
+        const latestHistory = histories.at(0);
+        if (latestHistory) {
+            messageHistory.restore(latestHistory);
+            console.info(`Resuming conversation: ${latestHistory.title}`);
+            // Set terminal title after restoring
+            terminal.setTitle(latestHistory.title || `acai: ${process.cwd()}`);
+        }
+        else {
+            logger.info("No previous conversation found to continue.");
+        }
+    }
+    else if (flags.resume === true) {
+        const histories = await MessageHistory.load(messageHistoryDir, 10);
+        if (histories.length > 0) {
+            const choice = await select({
+                message: "Select a conversation to resume:",
+                choices: histories.map((h, index) => ({
+                    name: `${index + 1}: ${h.title} (${h.updatedAt.toLocaleString()})`,
+                    value: index,
+                    description: `${h.messages.length} messages`,
+                })),
+            });
+            const selectedHistory = histories.at(choice);
+            if (selectedHistory) {
+                messageHistory.restore(selectedHistory);
+                logger.info(`Resuming conversation: ${selectedHistory.title}`);
+                // Set terminal title after restoring
+                terminal.setTitle(selectedHistory.title || `acai: ${process.cwd()}`);
+            }
+            else {
+                // This case should theoretically not happen if choice is valid
+                logger.error("Selected history index out of bounds.");
+            }
+        }
+        else {
+            logger.info("No previous conversations found to resume.");
+        }
+    }
+    // --- Setup Prompt Manager (only if not continuing/resuming) ---
+    const promptManager = new PromptManager(tokenCounter);
+    if (!hasContinueOrResume && isDefined(initialPromptInput)) {
+        promptManager.set(initialPromptInput);
+    }
+    if (stdInPrompt) {
+        promptManager.addContext(stdInPrompt);
+    }
+    const toolEvents = new Map();
+    const commands = new CommandManager({
+        promptManager,
+        modelManager,
+        terminal,
+        messageHistory,
+        tokenTracker,
+        config,
+        tokenCounter,
+        toolEvents,
+    });
+    if (flags.oneshot === true) {
+        const cliProcess = new Cli({
+            promptManager,
+            config: appConfig,
+            messageHistory,
+            modelManager,
+            tokenTracker,
+            tokenCounter,
+        });
+        return (await asyncTry(cliProcess.run())).recover(handleError);
+    }
+    const repl = new Repl({
+        promptManager,
+        terminal,
+        config: appConfig,
+        messageHistory,
+        modelManager,
+        tokenTracker,
+        commands,
+        tokenCounter,
+        toolEvents,
+        autoAcceptAll: flags.autoAcceptAll === true,
+    });
+    return (await asyncTry(repl.run())).recover(handleError);
+}
+main();

package/dist/source/logger.d.ts

@@ -0,0 +1,2 @@
+import pino from "pino";
+export declare const logger: pino.Logger<never, boolean>;

package/dist/source/logger.js

@@ -0,0 +1,24 @@
+import { join } from "node:path";
+import pino from "pino";
+import { config } from "./config.js";
+const transport = pino.transport({
+    target: "pino-roll",
+    options: {
+        file: join(config.app.ensurePathSync("logs"), "acai.log"),
+        size: "10m",
+        symlink: true,
+        limit: {
+            count: 3,
+        },
+        mkdir: true,
+    },
+});
+export const logger = pino({
+    level: process.env["LOG_LEVEL"] ?? "debug",
+    formatters: {
+        level: (label) => {
+            return { level: label.toUpperCase() };
+        },
+    },
+    timestamp: pino.stdTimeFunctions.isoTime,
+}, transport);

package/dist/source/mentions.d.ts

@@ -0,0 +1,9 @@
+import type { ModelMetadata } from "./models/providers.ts";
+import type { ContextItem } from "./prompts/manager.ts";
+export declare function processPrompt(message: string, { baseDir, model }: {
+    baseDir: string;
+    model: ModelMetadata;
+}): Promise<{
+    message: string;
+    context: ContextItem[];
+}>;