@travisennis/acai 0.0.1 → 0.0.2

package/dist/source/commands/usage-command.js

@@ -1,21 +0,0 @@
-export function usageCommand({ terminal, tokenTracker, }) {
-    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/dist/source/config.d.ts

@@ -1,60 +0,0 @@
-import { z } from "zod";
-export declare class DirectoryProvider {
-    private baseDir;
-    constructor(baseDir: string);
-    getPath(subdir?: string): string;
-    ensurePath(subdir?: string): Promise<string>;
-    ensurePathSync(subdir?: string): string;
-}
-export declare class ConfigManager {
-    readonly project: DirectoryProvider;
-    readonly app: DirectoryProvider;
-    constructor();
-    private _readConfig;
-    readProjectConfig(): Promise<ProjectConfig>;
-    readAgentsFile(): Promise<string>;
-    writeAgentsFile(rules: string): Promise<void>;
-    readProjectLearnedRulesFile(): Promise<string>;
-    writeProjectLearnedRulesFile(rules: string): Promise<void>;
-    readCachedLearnedRulesFile(): Promise<string>;
-    writeCachedLearnedRulesFile(rules: string): Promise<void>;
-    readAppConfig(configName: string): Promise<Record<PropertyKey, unknown>>;
-    ensureAppConfig(configName: string): Promise<Record<PropertyKey, unknown>>;
-    writeAppConfig(configName: string, data: Record<PropertyKey, unknown>): Promise<void>;
-}
-declare const ProjectConfigSchema: z.ZodObject<{
-    logs: z.ZodOptional<z.ZodObject<{
-        path: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        path: string;
-    }, {
-        path: string;
-    }>>;
-    tools: z.ZodDefault<z.ZodOptional<z.ZodObject<{
-        maxTokens: z.ZodDefault<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        maxTokens: number;
-    }, {
-        maxTokens?: number | undefined;
-    }>>>;
-    notify: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-}, "strip", z.ZodTypeAny, {
-    tools: {
-        maxTokens: number;
-    };
-    notify: boolean;
-    logs?: {
-        path: string;
-    } | undefined;
-}, {
-    logs?: {
-        path: string;
-    } | undefined;
-    tools?: {
-        maxTokens?: number | undefined;
-    } | undefined;
-    notify?: boolean | undefined;
-}>;
-export type ProjectConfig = z.infer<typeof ProjectConfigSchema>;
-export declare const config: ConfigManager;
-export {};

package/dist/source/config.js

@@ -1,193 +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.js";
-export class DirectoryProvider {
-    baseDir;
-    constructor(baseDir) {
-        this.baseDir = baseDir;
-    }
-    getPath(subdir) {
-        return subdir ? path.join(this.baseDir, subdir) : this.baseDir;
-    }
-    // Async-by-default: prefer non-blocking filesystem operations.
-    async ensurePath(subdir) {
-        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) {
-        const dirPath = this.getPath(subdir);
-        mkdirSync(dirPath, { recursive: true });
-        return dirPath;
-    }
-}
-export class ConfigManager {
-    project;
-    app;
-    constructor() {
-        this.project = new DirectoryProvider(path.join(process.cwd(), ".acai"));
-        this.app = new DirectoryProvider(path.join(homedir(), ".acai"));
-    }
-    async _readConfig(configPath) {
-        try {
-            const data = await fs.readFile(configPath, "utf8");
-            return jsonParser(ProjectConfigSchema).parse(data);
-        }
-        catch (error) {
-            if (error.code === "ENOENT") {
-                return {};
-            }
-            throw error;
-        }
-    }
-    // Project config helpers
-    async readProjectConfig() {
-        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() {
-        const agentsPath = path.join(process.cwd(), "AGENTS.md");
-        try {
-            return await fs.readFile(agentsPath, "utf8");
-        }
-        catch (error) {
-            if (error.code === "ENOENT") {
-                return "";
-            }
-            throw error;
-        }
-    }
-    async writeAgentsFile(rules) {
-        const agentsPath = path.join(process.cwd(), "AGENTS.md");
-        try {
-            return await fs.writeFile(agentsPath, rules, "utf8");
-        }
-        catch (error) {
-            if (error.code === "ENOENT") {
-                return;
-            }
-            throw error;
-        }
-    }
-    // Project-specific learned rules
-    async readProjectLearnedRulesFile() {
-        const rulesPath = path.join(this.project.getPath("rules"), "learned-rules.md");
-        try {
-            return await fs.readFile(rulesPath, "utf8");
-        }
-        catch (error) {
-            if (error.code === "ENOENT") {
-                return "";
-            }
-            throw error;
-        }
-    }
-    async writeProjectLearnedRulesFile(rules) {
-        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.code === "ENOENT") {
-                return;
-            }
-            throw error;
-        }
-    }
-    // App-cached learned rules (used during conversation analysis)
-    async readCachedLearnedRulesFile() {
-        const rulesPath = path.join(this.app.getPath("rules"), "learned-rules.md");
-        try {
-            return await fs.readFile(rulesPath, "utf8");
-        }
-        catch (error) {
-            if (error.code === "ENOENT") {
-                return "";
-            }
-            throw error;
-        }
-    }
-    async writeCachedLearnedRulesFile(rules) {
-        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.code === "ENOENT") {
-                return;
-            }
-            throw error;
-        }
-    }
-    // App config helpers
-    async readAppConfig(configName) {
-        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.code === "ENOENT") {
-                return {};
-            }
-            throw error;
-        }
-    }
-    async ensureAppConfig(configName) {
-        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, data) {
-        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),
-});
-// Create a singleton instance
-export const config = new ConfigManager();

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

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

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

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

package/dist/source/dedent.js

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

@@ -1,17 +0,0 @@
-/**
- * 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

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

@@ -1,18 +0,0 @@
-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 {};