@travisennis/acai 0.0.4 → 0.0.6

package/dist/commands/files-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"files-command.d.ts","sourceRoot":"","sources":["../../source/commands/files-command.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9D,eAAO,MAAM,YAAY,GAAI,4CAI1B,cAAc,KAAG,WA8KnB,CAAC"}

package/dist/commands/files-command.js

@@ -1,20 +1,21 @@
 import { readFile } from "node:fs/promises";
-import { checkbox } from "@inquirer/prompts";
-import { globby } from "globby";
 import { formatFile } from "../formatting.js";
-import { TokenCounter } from "../token-utils.js";
+import { checkbox } from "../terminal/checkbox-prompt.js";
+import style from "../terminal/style.js";
+import { TokenCounter } from "../tokens/counter.js";
+import { Text } from "../tui/index.js";
+import { glob } from "../utils/glob.js";
 export const filesCommand = ({ terminal, promptManager, modelManager, }) => {
     return {
         command: "/files",
         description: "Finds files matching the given patterns and adds their content to the next prompt. Usage: /files or /files src/**/*.ts",
-        result: "continue",
         getSubCommands: () => Promise.resolve([]),
         execute: async (args) => {
             try {
                 let workingFiles = [];
                 if (!args || args.length === 0) {
                     // Get all files in the current directory
-                    const foundFiles = await globby("**/*", { gitignore: true });
+                    const foundFiles = await glob("**/*", { gitignore: true });
                     const selectedFiles = await checkbox({
                         message: "Select files to include:",
                         choices: foundFiles,
@@ -22,17 +23,17 @@ export const filesCommand = ({ terminal, promptManager, modelManager, }) => {
                     });
                     if (selectedFiles.length === 0) {
                         terminal.warn("No files selected.");
-                        return;
+                        return "continue";
                     }
                     // Process the selected files
                     workingFiles = selectedFiles;
                 }
                 else {
                     const patternList = args.filter(Boolean);
-                    const foundFiles = await globby(patternList, { gitignore: true });
+                    const foundFiles = await glob(patternList, { gitignore: true });
                     if (foundFiles.length === 0) {
                         terminal.warn("No files found matching the pattern(s)");
-                        return;
+                        return "continue";
                     }
                     // Process the selected files
                     workingFiles = foundFiles;
@@ -54,9 +55,66 @@ export const filesCommand = ({ terminal, promptManager, modelManager, }) => {
                 }));
                 tokenCounter.free();
                 terminal.success(`File contents will be added to your next prompt (${workingFiles.length} files, ${tokenCount} tokens)`);
+                return "continue";
             }
             catch (error) {
                 terminal.error(`Error processing file patterns: ${error.message}`);
+                return "continue";
+            }
+        },
+        async handle(args, { tui, container, editor, }) {
+            try {
+                let workingFiles = [];
+                if (!args || args.length === 0) {
+                    // Get all files in the current directory
+                    const foundFiles = await glob("**/*", { gitignore: true });
+                    // For TUI mode, we'll just use the first few files
+                    workingFiles = foundFiles.slice(0, 5);
+                    if (workingFiles.length === 0) {
+                        container.addChild(new Text(style.yellow("No files found"), 0, 1));
+                        tui.requestRender();
+                        editor.setText("");
+                        return "continue";
+                    }
+                }
+                else {
+                    const patternList = args.filter(Boolean);
+                    const foundFiles = await glob(patternList, { gitignore: true });
+                    if (foundFiles.length === 0) {
+                        container.addChild(new Text(style.yellow("No files found matching the pattern(s)"), 1, 0));
+                        tui.requestRender();
+                        editor.setText("");
+                        return "continue";
+                    }
+                    // Process the selected files
+                    workingFiles = foundFiles;
+                }
+                // Read the content of the files and format them for the next prompt
+                const format = modelManager.getModelMetadata("repl").promptFormat;
+                let tokenCount = 0;
+                const tokenCounter = new TokenCounter();
+                await Promise.all(workingFiles.map(async (filePath) => {
+                    try {
+                        const content = await readFile(filePath, "utf-8");
+                        const formattedFile = formatFile(filePath, content, format);
+                        tokenCount += tokenCounter.count(formattedFile);
+                        promptManager.addContext(formattedFile);
+                    }
+                    catch (error) {
+                        container.addChild(new Text(style.red(`Error reading file ${filePath}: ${error.message}`), 1, 0));
+                    }
+                }));
+                tokenCounter.free();
+                container.addChild(new Text(style.green(`File contents will be added to your next prompt (${workingFiles.length} files, ${tokenCount} tokens)`), 1, 0));
+                tui.requestRender();
+                editor.setText("");
+                return "continue";
+            }
+            catch (error) {
+                container.addChild(new Text(style.red(`Error processing file patterns: ${error.message}`), 1, 0));
+                tui.requestRender();
+                editor.setText("");
+                return "continue";
             }
         },
     };

package/dist/commands/generate-rules-command.d.ts

@@ -1,2 +1,3 @@
 import type { CommandOptions, ReplCommand } from "./types.ts";
 export declare const generateRulesCommand: ({ terminal, messageHistory, modelManager, tokenTracker, config, }: CommandOptions) => ReplCommand;
+//# sourceMappingURL=generate-rules-command.d.ts.map

package/dist/commands/generate-rules-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-rules-command.d.ts","sourceRoot":"","sources":["../../source/commands/generate-rules-command.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAuC9D,eAAO,MAAM,oBAAoB,GAAI,mEAMlC,cAAc,KAAG,WA6JnB,CAAC"}

package/dist/commands/generate-rules-command.js

@@ -1,6 +1,12 @@
-import { checkbox } from "@inquirer/prompts";
-import { analyzeConversation } from "../conversation-analyzer.js";
+import { generateText } from "ai";
+import { config } from "../config.js";
 import { logger } from "../logger.js"; // Import logger
+import { createUserMessage } from "../messages.js";
+import { systemPrompt } from "../prompts.js";
+import { checkbox } from "../terminal/checkbox-prompt.js";
+import { getTerminalSize } from "../terminal/formatting.js";
+import style from "../terminal/style.js";
+import { Container, Input, Spacer, Text, } from "../tui/index.js";
 async function _processAndSaveRules(newRules, terminal, config) {
     if (!newRules || newRules.length === 0) {
         terminal.warn("No new generalizable rules were identified.");
@@ -32,12 +38,11 @@ export const generateRulesCommand = ({ terminal, messageHistory, modelManager, t
     return {
         command: "/generate-rules",
         description: "Analyzes the current conversation to generate and save new interaction rules, then displays them.",
-        result: "continue",
         getSubCommands: () => Promise.resolve([]),
         execute: async () => {
             if (messageHistory.isEmpty()) {
                 terminal.writeln("Cannot generate rules from an empty conversation.");
-                return;
+                return "continue";
             }
             terminal.lineBreak();
             terminal.info("Analyzing conversation to generate rules...");
@@ -55,7 +60,313 @@ export const generateRulesCommand = ({ terminal, messageHistory, modelManager, t
                 const errorMessage = error instanceof Error ? error.message : String(error);
                 terminal.error(`Error generating rules: ${errorMessage}`);
                 logger.error(error, "Error during rule generation:");
+                return "continue";
+            }
+            return "continue";
+        },
+        async handle(_args, { tui, container, inputContainer, editor, }) {
+            if (messageHistory.isEmpty()) {
+                container.addChild(new Text(style.yellow("Cannot generate rules from an empty conversation."), 1, 0));
+                tui.requestRender();
+                editor.setText("");
+                return "continue";
+            }
+            container.addChild(new Text("Analyzing conversation to generate rules...", 0, 1));
+            tui.requestRender();
+            try {
+                const newRules = await analyzeConversation({
+                    modelManager,
+                    messages: messageHistory.get(),
+                    tokenTracker,
+                    terminal,
+                });
+                if (!newRules || newRules.length === 0) {
+                    container.addChild(new Text(style.yellow("No new generalizable rules were identified."), 2, 0));
+                    tui.requestRender();
+                    editor.setText("");
+                    return "continue";
+                }
+                // Create rule selector for TUI mode
+                const ruleSelector = new RuleSelectorComponent(newRules, async (selectedRules) => {
+                    // Handle rule selection
+                    if (selectedRules.length === 0) {
+                        container.addChild(new Text(style.yellow("No rules selected to save."), 2, 0));
+                    }
+                    else {
+                        try {
+                            const existingRules = await config.readProjectLearnedRulesFile();
+                            const rulesToAdd = selectedRules.join("\n");
+                            const updatedProjectRules = existingRules.endsWith("\n") || existingRules.length === 0
+                                ? `${existingRules}${rulesToAdd}`
+                                : `${existingRules}\n${rulesToAdd}`;
+                            await config.writeProjectLearnedRulesFile(updatedProjectRules);
+                            container.addChild(new Text(style.green("Selected rules saved to project learned rules."), 2, 0));
+                            container.addChild(new Text(style.dim("Saved rules:"), 3, 0));
+                            selectedRules.forEach((rule, index) => {
+                                container.addChild(new Text(`- ${rule}`, 4 + index, 0));
+                            });
+                        }
+                        catch (error) {
+                            container.addChild(new Text(style.red(`Failed to save rules: ${error}`), 2, 0));
+                        }
+                    }
+                    // Hide selector and show editor again
+                    hideRuleSelector(inputContainer, editor, tui);
+                    tui.requestRender();
+                }, () => {
+                    // Cancel selection - just hide selector
+                    hideRuleSelector(inputContainer, editor, tui);
+                    tui.requestRender();
+                });
+                // Replace editor with rule selector
+                inputContainer.clear();
+                inputContainer.addChild(ruleSelector);
+                tui.setFocus(ruleSelector);
+                tui.requestRender();
+                return "continue";
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                container.addChild(new Text(style.red(`Error generating rules: ${errorMessage}`), 0, 1));
+                logger.error(error, "Error during rule generation:");
+                tui.requestRender();
+                editor.setText("");
+                return "continue";
             }
         },
     };
 };
+// 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>`;
+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
+}
+function hideRuleSelector(editorContainer, editor, tui) {
+    // Replace selector with editor in the container
+    editorContainer.clear();
+    editorContainer.addChild(editor);
+    tui.setFocus(editor);
+}
+/**
+ * Component that renders a rule selector with search and multi-selection
+ */
+class RuleSelectorComponent extends Container {
+    searchInput;
+    listContainer;
+    allRules = [];
+    filteredRules = [];
+    selectedIndex = 0;
+    selectedRules = new Set();
+    onSelectCallback;
+    onCancelCallback;
+    constructor(rules, onSelect, onCancel) {
+        super();
+        this.onSelectCallback = onSelect;
+        this.onCancelCallback = onCancel;
+        // Load all rules
+        this.allRules = rules;
+        this.filteredRules = rules;
+        const { columns } = getTerminalSize();
+        // Add top border
+        this.addChild(new Text(style.blue("─".repeat(columns)), 0, 0));
+        this.addChild(new Spacer(1));
+        // Create search input
+        this.searchInput = new Input();
+        this.searchInput.onSubmit = () => {
+            // Enter on search input toggles selection of current item
+            this.toggleSelection(this.selectedIndex);
+        };
+        this.addChild(this.searchInput);
+        this.addChild(new Spacer(1));
+        // Create list container
+        this.listContainer = new Container();
+        this.addChild(this.listContainer);
+        this.addChild(new Spacer(1));
+        // Add instructions
+        this.addChild(new Text(style.dim("Space: toggle selection, Enter: confirm, Escape: cancel"), 0, 0));
+        this.addChild(new Spacer(1));
+        // Add bottom border
+        this.addChild(new Text(style.blue("─".repeat(columns)), 0, 0));
+        // Initial render
+        this.updateList();
+    }
+    filterRules(query) {
+        if (!query.trim()) {
+            this.filteredRules = this.allRules;
+        }
+        else {
+            const searchTokens = query
+                .toLowerCase()
+                .split(/\s+/)
+                .filter((t) => t);
+            this.filteredRules = this.allRules.filter((rule) => {
+                const searchText = rule.toLowerCase();
+                return searchTokens.every((token) => searchText.includes(token));
+            });
+        }
+        this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, this.filteredRules.length - 1));
+        this.updateList();
+    }
+    updateList() {
+        this.listContainer.clear();
+        const maxVisible = 10;
+        const startIndex = Math.max(0, Math.min(this.selectedIndex - Math.floor(maxVisible / 2), this.filteredRules.length - maxVisible));
+        const endIndex = Math.min(startIndex + maxVisible, this.filteredRules.length);
+        // Show visible slice of filtered rules
+        for (let i = startIndex; i < endIndex; i++) {
+            const rule = this.filteredRules[i];
+            if (!rule)
+                continue;
+            const isSelected = i === this.selectedIndex;
+            const isChecked = this.selectedRules.has(i);
+            let line = "";
+            if (isSelected) {
+                const prefix = style.blue("→ ");
+                const checkbox = isChecked ? style.green("[✓] ") : "[ ] ";
+                const ruleText = rule;
+                line = `${prefix + checkbox + style.blue(ruleText)}`;
+            }
+            else {
+                const checkbox = isChecked ? style.green("[✓] ") : "[ ] ";
+                const ruleText = `  ${rule}`;
+                line = `${checkbox + ruleText}`;
+            }
+            this.listContainer.addChild(new Text(line, 0, 0));
+        }
+        // Add scroll indicator if needed
+        if (startIndex > 0 || endIndex < this.filteredRules.length) {
+            const scrollInfo = style.gray(`  (${this.selectedIndex + 1}/${this.filteredRules.length})`);
+            this.listContainer.addChild(new Text(scrollInfo, 0, 0));
+        }
+        // Show "no results" if empty
+        if (this.filteredRules.length === 0) {
+            this.listContainer.addChild(new Text(style.gray("  No matching rules"), 0, 0));
+        }
+    }
+    handleInput(keyData) {
+        // Up arrow
+        if (keyData === "\x1b[A") {
+            this.selectedIndex = Math.max(0, this.selectedIndex - 1);
+            this.updateList();
+        }
+        // Down arrow
+        else if (keyData === "\x1b[B") {
+            this.selectedIndex = Math.min(this.filteredRules.length - 1, this.selectedIndex + 1);
+            this.updateList();
+        }
+        // Space - toggle selection
+        else if (keyData === " ") {
+            this.toggleSelection(this.selectedIndex);
+        }
+        // Enter - confirm selection
+        else if (keyData === "\r") {
+            this.handleConfirm();
+        }
+        // Escape
+        else if (keyData === "\x1b") {
+            this.onCancelCallback();
+        }
+        // Pass everything else to search input
+        else {
+            this.searchInput.handleInput(keyData);
+            this.filterRules(this.searchInput.getValue());
+        }
+    }
+    toggleSelection(index) {
+        if (this.selectedRules.has(index)) {
+            this.selectedRules.delete(index);
+        }
+        else {
+            this.selectedRules.add(index);
+        }
+        this.updateList();
+    }
+    handleConfirm() {
+        const selectedRuleTexts = Array.from(this.selectedRules)
+            .map((index) => this.filteredRules[index])
+            .filter((rule) => rule !== undefined);
+        this.onSelectCallback(selectedRuleTexts);
+    }
+    getSearchInput() {
+        return this.searchInput;
+    }
+}

package/dist/commands/handoff-command.d.ts

@@ -0,0 +1,3 @@
+import type { CommandOptions, ReplCommand } from "./types.ts";
+export declare const handoffCommand: (options: CommandOptions) => ReplCommand;
+//# sourceMappingURL=handoff-command.d.ts.map

package/dist/commands/handoff-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handoff-command.d.ts","sourceRoot":"","sources":["../../source/commands/handoff-command.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9D,eAAO,MAAM,cAAc,GAAI,SAAS,cAAc,KAAG,WAkExD,CAAC"}