@travisennis/acai 0.0.8 → 0.0.10

package/dist/agent/sub-agent.js

@@ -0,0 +1,109 @@
+import { generateText, stepCountIs } from "ai";
+import { config } from "../config/index.js";
+import { AiConfig } from "../models/ai-config.js";
+import { getLanguageModel, getModelMetadata } from "../models/manager.js";
+import { initTools } from "../tools/index.js";
+import { toAiSdkTools } from "../tools/utils.js";
+export class SubAgent {
+    workspace;
+    constructor(options) {
+        this.workspace = options.workspace;
+    }
+    async execute({ model, system, prompt, abortSignal, allowedTools, timeout, }) {
+        try {
+            const { tools, abortSignal: combinedSignal, timeoutId, } = await this.prepareExecution({
+                allowedTools,
+                timeout,
+                abortSignal,
+            });
+            try {
+                const result = await this.runGenerateText({
+                    model,
+                    system,
+                    prompt,
+                    tools,
+                    abortSignal: combinedSignal,
+                });
+                return result.text;
+            }
+            finally {
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                }
+            }
+        }
+        catch (error) {
+            throw this.transformError(error);
+        }
+    }
+    async prepareExecution({ allowedTools, timeout, abortSignal, }) {
+        let tools = await initTools({
+            workspace: this.workspace,
+        });
+        tools = this.filterTools(tools, allowedTools);
+        const { signal: timeoutSignal, timeoutId } = this.createTimeoutSignal(timeout);
+        const combinedSignal = this.combineAbortSignals(timeoutSignal, abortSignal);
+        return { tools, abortSignal: combinedSignal, timeoutId };
+    }
+    filterTools(tools, allowedTools) {
+        if (!allowedTools || allowedTools.length === 0) {
+            return tools;
+        }
+        const filteredTools = {};
+        for (const [key, value] of Object.entries(tools)) {
+            if (allowedTools.includes(key)) {
+                filteredTools[key] = value;
+            }
+        }
+        return filteredTools;
+    }
+    createTimeoutSignal(timeout) {
+        if (!timeout || timeout <= 0) {
+            return { signal: undefined, timeoutId: undefined };
+        }
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => {
+            controller.abort(new Error(`SubAgent timed out after ${timeout} seconds`));
+        }, timeout * 1000);
+        return { signal: controller.signal, timeoutId };
+    }
+    combineAbortSignals(timeoutSignal, abortSignal) {
+        const signals = [timeoutSignal, abortSignal].filter((s) => s != null);
+        if (signals.length === 0) {
+            return undefined;
+        }
+        if (signals.length === 1) {
+            return signals[0];
+        }
+        return AbortSignal.any(signals);
+    }
+    async runGenerateText({ model, system, prompt, tools, abortSignal, }) {
+        const modelConfig = getModelMetadata({ model });
+        const aiConfig = new AiConfig({
+            modelMetadata: modelConfig,
+            prompt,
+        });
+        const stateDir = await config.app.ensurePath("audit");
+        return generateText({
+            model: getLanguageModel({ model, app: "subagent", stateDir }),
+            maxOutputTokens: aiConfig.maxOutputTokens(),
+            system,
+            prompt,
+            temperature: aiConfig.temperature(),
+            topP: aiConfig.topP(),
+            stopWhen: stepCountIs(100),
+            providerOptions: aiConfig.providerOptions(),
+            tools: toAiSdkTools(tools),
+            abortSignal,
+        });
+    }
+    transformError(error) {
+        if (error.name === "AbortError" || error.name === "TimeoutError") {
+            if (error.message.includes("timed out")) {
+                return new Error(error.message);
+            }
+            return new Error(`SubAgent execution was aborted: ${error.message}`);
+        }
+        return error;
+    }
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,26 @@
+import type { WorkspaceContext } from "../index.ts";
+import type { ModelManager } from "../models/manager.js";
+import type { PromptManager } from "../prompts/manager.ts";
+import type { SessionManager } from "../sessions/manager.ts";
+import type { TokenCounter } from "../tokens/counter.ts";
+import type { TokenTracker } from "../tokens/tracker.ts";
+interface CliOptions {
+    sessionManager: SessionManager;
+    promptManager: PromptManager;
+    modelManager: ModelManager;
+    tokenTracker: TokenTracker;
+    tokenCounter: TokenCounter;
+    workspace: WorkspaceContext;
+    noSession?: boolean;
+}
+export declare class Cli {
+    private options;
+    constructor(options: CliOptions);
+    run(): Promise<void>;
+    private setupSignalHandlers;
+    private initializeAiConfig;
+    private handleAbort;
+    private handleError;
+}
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/cli/index.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE3D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE7D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAMzD,UAAU,UAAU;IAClB,cAAc,EAAE,cAAc,CAAC;IAC/B,aAAa,EAAE,aAAa,CAAC;IAC7B,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,EAAE,YAAY,CAAC;IAC3B,SAAS,EAAE,gBAAgB,CAAC;IAC5B,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,qBAAa,GAAG;IACd,OAAO,CAAC,OAAO,CAAa;gBAChB,OAAO,EAAE,UAAU;IAIzB,GAAG;IAiFT,OAAO,CAAC,mBAAmB;YAab,kBAAkB;YA8BlB,WAAW;IAYzB,OAAO,CAAC,WAAW;CAQpB"}

package/dist/{cli.js → cli/index.js}

@@ -1,121 +1,121 @@
-import { generateText, NoSuchToolError, Output, stepCountIs, tool, } from "ai";
-import { logger } from "./logger.js";
-import { AiConfig } from "./models/ai-config.js";
-import { systemPrompt } from "./prompts.js";
-import { BashTool } from "./tools/bash.js";
-import { EditFileTool } from "./tools/edit-file.js";
-import { GlobTool } from "./tools/glob.js";
-import { GrepTool } from "./tools/grep.js";
-import { initTools } from "./tools/index.js";
-import { ReadFileTool } from "./tools/read-file.js";
-const activeTools = [
-    EditFileTool.name,
-    ReadFileTool.name,
-    BashTool.name,
-    GrepTool.name,
-    GlobTool.name,
-];
+import { generateText, NoSuchToolError, Output, stepCountIs, } from "ai";
+import { config } from "../config/index.js";
+import { AiConfig } from "../models/ai-config.js";
+import { systemPrompt } from "../prompts/system-prompt.js";
+import { printExitSummary } from "../sessions/summary.js";
+import { initTools } from "../tools/index.js";
+import { toAiSdkTools } from "../tools/utils.js";
+import { logger } from "../utils/logger.js";
 export class Cli {
     options;
-    skillsEnabled;
     constructor(options) {
         this.options = options;
-        this.skillsEnabled = options.skillsEnabled ?? true;
     }
     async run() {
-        const { promptManager, modelManager, tokenTracker, messageHistory } = this.options;
+        const { promptManager, modelManager, tokenTracker, sessionManager } = this.options;
         const abortController = new AbortController();
         const { signal } = abortController;
-        const cb = () => {
-            abortController.abort();
-        };
-        // Handle Ctrl+C (SIGINT)
-        process.on("SIGINT", cb);
+        const { cleanup } = this.setupSignalHandlers(abortController);
         const langModel = modelManager.getModel("cli");
         const modelConfig = modelManager.getModelMetadata("cli");
         const userPrompt = promptManager.get();
         const userMsg = promptManager.getUserMessage();
-        messageHistory.appendUserMessage(userMsg);
-        const finalSystemPrompt = await systemPrompt({
-            activeTools,
-            allowedDirs: this.options.workspace.allowedDirs,
-            skillsEnabled: this.skillsEnabled,
-        });
-        const aiConfig = new AiConfig({
-            modelMetadata: modelConfig,
-            prompt: userPrompt,
-        });
-        const tools = await initTools({
-            workspace: this.options.workspace,
+        sessionManager.appendUserMessage(userMsg);
+        const { aiConfig, finalSystemPrompt, tools } = await this.initializeAiConfig({
+            userPrompt,
+            modelConfig,
         });
-        // Cleanup function to remove signal handler
-        const cleanup = () => {
-            process.removeListener("SIGINT", cb);
-        };
         try {
             const result = await generateText({
                 model: langModel,
                 maxOutputTokens: aiConfig.maxOutputTokens(),
                 system: finalSystemPrompt,
-                messages: messageHistory.get(),
+                messages: sessionManager.get(),
                 temperature: aiConfig.temperature(),
                 topP: aiConfig.topP(),
                 stopWhen: stepCountIs(200),
                 maxRetries: 2,
                 providerOptions: aiConfig.providerOptions(),
-                tools: Object.fromEntries(Object.entries(tools).map((t) => [
-                    t[0],
-                    tool({
-                        ...t[1]["toolDef"],
-                        execute: t[1]["execute"],
-                    }),
-                ])),
-                activeTools,
+                tools: toAiSdkTools(tools),
                 // biome-ignore lint/style/useNamingConvention: third-party controlled
                 experimental_repairToolCall: toolCallRepair(modelManager),
                 abortSignal: signal,
             });
             if (result.response.messages.length > 0) {
-                messageHistory.appendResponseMessages(result.response.messages);
+                sessionManager.appendResponseMessages(result.response.messages);
             }
             // this tracks the usage of every step in the call to streamText. it's a cumulative usage.
             tokenTracker.trackUsage("cli", result.usage);
-            await messageHistory.save();
+            if (!this.options.noSession) {
+                await sessionManager.save();
+            }
             process.stdout.end(result.text.endsWith("\n") ? result.text : `${result.text}\n`);
+            if (!sessionManager.isEmpty()) {
+                printExitSummary(sessionManager, this.options.noSession);
+            }
             cleanup();
+            process.exit(0);
         }
         catch (e) {
-            // Always cleanup signal handler
             cleanup();
-            // Check if it's an abort error or if the signal was aborted
             const isAbortError = (e instanceof Error &&
                 (e.name === "AbortError" ||
                     e.message.includes("aborted") ||
                     e.message.includes("No output generated"))) ||
                 signal.aborted;
             if (isAbortError) {
-                logger.info("CLI execution interrupted by user");
-                // Try to save message history before exiting
-                try {
-                    await messageHistory.save();
-                }
-                catch (_saveError) {
-                    // Ignore save errors on abort
-                    logger.warn("Failed to save message history on interrupt");
-                }
-                process.exit(0); // Exit gracefully
+                await this.handleAbort();
             }
             else {
-                if (e instanceof Error) {
-                    logger.error(e);
-                }
-                else {
-                    logger.error(JSON.stringify(e, null, 2));
-                }
-                process.exit(1);
+                this.handleError(e);
             }
         }
     }
+    setupSignalHandlers(abortController) {
+        const cb = abortController.abort.bind(abortController);
+        process.on("SIGINT", cb);
+        const cleanup = () => {
+            process.removeListener("SIGINT", cb);
+        };
+        return { cleanup };
+    }
+    async initializeAiConfig({ userPrompt, modelConfig, }) {
+        const cliConfig = await config.getConfig();
+        const finalSystemPromptResult = await systemPrompt({
+            allowedDirs: this.options.workspace.allowedDirs,
+            logsPath: cliConfig.logs?.path,
+        });
+        const finalSystemPrompt = finalSystemPromptResult.prompt;
+        const aiConfig = new AiConfig({
+            modelMetadata: modelConfig,
+            prompt: userPrompt,
+        });
+        const tools = await initTools({
+            workspace: this.options.workspace,
+        });
+        return { aiConfig, finalSystemPrompt, tools };
+    }
+    async handleAbort() {
+        logger.info("CLI execution interrupted by user");
+        if (!this.options.noSession) {
+            try {
+                await this.options.sessionManager.save();
+            }
+            catch {
+                logger.warn("Failed to save message history on interrupt");
+            }
+        }
+        process.exit(0);
+    }
+    handleError(e) {
+        if (e instanceof Error) {
+            logger.error(e);
+        }
+        else {
+            logger.error(JSON.stringify(e, null, 2));
+        }
+        process.exit(1);
+    }
 }
 const toolCallRepair = (modelManager) => {
     const fn = async ({ toolCall, tools, inputSchema, error, }) => {
@@ -130,11 +130,19 @@ const toolCallRepair = (modelManager) => {
                     schema: tool.inputSchema,
                 }),
                 prompt: [
-                    `The model tried to call the tool "${toolCall.toolName}" with the following arguments:`,
-                    JSON.stringify(toolCall.input),
-                    "The tool accepts the following schema:",
-                    JSON.stringify(inputSchema(toolCall)),
-                    "Please fix the arguments.",
+                    `The model tried to call the tool "${toolCall.toolName}" but the input did not match the expected schema.`,
+                    "",
+                    "<invalid_input>",
+                    JSON.stringify(toolCall.input, null, 2),
+                    "</invalid_input>",
+                    "",
+                    "<expected_schema>",
+                    JSON.stringify(await inputSchema({ toolName: toolCall.toolName }), null, 2),
+                    "</expected_schema>",
+                    "",
+                    "If any field is missing or undefined in the corrected input, you MUST explicitly set its value to null. Do NOT omit fields - every field in the schema must be present, even if with a null value.",
+                    "",
+                    "Return a corrected version of the input that conforms to the expected schema.",
                 ].join("\n"),
             });
             return { ...toolCall, args: JSON.stringify(repairedArgs) };

package/dist/cli/stdin.d.ts

@@ -0,0 +1,9 @@
+export declare const STDIN_SOFT_LIMIT: number;
+export declare const STDIN_HARD_LIMIT: number;
+export interface StdinResult {
+    content: string | null;
+    sizeBytes: number;
+    wasPiped: boolean;
+}
+export declare function readStdinWithLimits(): Promise<StdinResult>;
+//# sourceMappingURL=stdin.d.ts.map

package/dist/cli/stdin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdin.d.ts","sourceRoot":"","sources":["../../source/cli/stdin.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,gBAAgB,QAAY,CAAC;AAC1C,eAAO,MAAM,gBAAgB,QAAa,CAAC;AAE3C,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC,CA2ChE"}

package/dist/cli/stdin.js

@@ -0,0 +1,37 @@
+import { text } from "node:stream/consumers";
+export const STDIN_SOFT_LIMIT = 50 * 1024; // 50KB
+export const STDIN_HARD_LIMIT = 200 * 1024; // 200KB
+export async function readStdinWithLimits() {
+    if (process.stdin.isTTY) {
+        return { content: null, sizeBytes: 0, wasPiped: false };
+    }
+    // Check if stdin is a pipe (piped input) vs just not a TTY
+    // When stdin is a TTY or a pipe, we can read from it
+    // When stdin is neither (e.g., running in background without TTY or pipe), treat as empty
+    const isPipe = process.stdin.readableObjectMode ||
+        // @ts-expect-error - _isStdio is internal
+        process.stdin._isStdio;
+    // Check if stdin has data by attempting a non-blocking read
+    // If stdin is not a pipe and not a TTY, treat it as empty (no input)
+    if (!isPipe) {
+        return { content: null, sizeBytes: 0, wasPiped: false };
+    }
+    try {
+        const content = await text(process.stdin);
+        const sizeBytes = Buffer.byteLength(content, "utf8");
+        if (sizeBytes > STDIN_HARD_LIMIT) {
+            const sizeKb = Math.round(sizeBytes / 1024);
+            console.error(`Error: Input exceeds ${STDIN_HARD_LIMIT / 1024}KB size limit (${sizeKb}KB provided).`);
+            process.exit(1);
+        }
+        if (sizeBytes > STDIN_SOFT_LIMIT) {
+            const sizeKb = Math.round(sizeBytes / 1024);
+            console.error(`Warning: Input is ${sizeKb}KB. Large inputs may increase latency and costs.`);
+        }
+        return { content, sizeBytes, wasPiped: true };
+    }
+    catch (error) {
+        console.error(`Error reading stdin: ${error.message}`);
+        return { content: null, sizeBytes: 0, wasPiped: true };
+    }
+}

package/dist/commands/copy/index.js

@@ -10,8 +10,8 @@ export function copyCommand(options) {
             return [];
         },
         async handle(_args, { tui, container, editor, }) {
-            const { sessionManager: messageHistory } = options;
-            const history = messageHistory.get();
+            const { sessionManager } = options;
+            const history = sessionManager.get();
             container.addChild(new Spacer(1));
             const lastText = extractLastAssistantText(history);
             if (!lastText) {

package/dist/commands/copy/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../source/commands/copy/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAY,MAAM,IAAI,CAAC;AAEjD,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,YAAY,EAAE,GACvB,MAAM,GAAG,IAAI,CAoBf"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../source/commands/copy/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAY,MAAM,IAAI,CAAC;AAYjD,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,YAAY,EAAE,GACvB,MAAM,GAAG,IAAI,CAUf"}

package/dist/commands/copy/utils.js

@@ -1,22 +1,24 @@
+function findLastNonEmptyText(content) {
+    for (let j = content.length - 1; j >= 0; j--) {
+        const part = content[j];
+        if (part?.type !== "text")
+            continue;
+        const text = part.text;
+        if (typeof text === "string" && text.trim().length > 0)
+            return text;
+    }
+    return null;
+}
 export function extractLastAssistantText(messages) {
     for (let i = messages.length - 1; i >= 0; i--) {
         const msg = messages[i];
-        if (!msg)
-            continue;
-        if (msg.role !== "assistant")
+        if (msg?.role !== "assistant")
             continue;
         if (!("content" in msg) || !Array.isArray(msg.content))
             continue;
-        for (let j = msg.content.length - 1; j >= 0; j--) {
-            const part = msg.content[j];
-            if (part != null &&
-                part.type === "text" &&
-                typeof part.text === "string") {
-                const text = part.text;
-                if (text.trim().length > 0)
-                    return text;
-            }
-        }
+        const text = findLastNonEmptyText(msg.content);
+        if (text !== null)
+            return text;
     }
     return null;
 }

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../source/commands/generate-rules/index.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/D,eAAO,MAAM,oBAAoB,GAAI,oFAMlC,cAAc,KAAG,WA+HnB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../source/commands/generate-rules/index.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAI/D,eAAO,MAAM,oBAAoB,GAAI,oEAMlC,cAAc,KAAG,WA4HnB,CAAC"}

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

@@ -1,18 +1,16 @@
-import { generateText } from "ai";
-import { logger } from "../../logger.js";
-import { systemPrompt } from "../../prompts.js";
-import { createUserMessage } from "../../sessions/manager.js";
-import { getTerminalSize, isArrowDown, isArrowUp, isEnter, isEscape, } from "../../terminal/control.js";
+import { getTerminalSize, isArrowDown, isArrowUp, isEnter, isEscape, isShiftTab, isTab, } from "../../terminal/control.js";
 import style from "../../terminal/style.js";
 import { Container, Input, Spacer, Text, } from "../../tui/index.js";
+import { logger } from "../../utils/logger.js";
+import { generateRulesFromSession } from "./service.js";
 import { hideRuleSelector } from "./utils.js";
-export const generateRulesCommand = ({ sessionManager: messageHistory, modelManager, tokenTracker, config, workspace, }) => {
+export const generateRulesCommand = ({ sessionManager, modelManager, tokenTracker, config, workspace, }) => {
     return {
         command: "/generate-rules",
         description: "Analyzes the current conversation to generate and save new interaction rules, then displays them.",
         getSubCommands: () => Promise.resolve([]),
         async handle(_args, { tui, container, inputContainer, editor, }) {
-            if (messageHistory.isEmpty()) {
+            if (sessionManager.isEmpty()) {
                 container.addChild(new Text(style.yellow("Cannot generate rules from an empty conversation."), 1, 0));
                 tui.requestRender();
                 editor.setText("");
@@ -21,9 +19,9 @@ export const generateRulesCommand = ({ sessionManager: messageHistory, modelMana
             container.addChild(new Text("Analyzing conversation to generate rules...", 0, 1));
             tui.requestRender();
             try {
-                const newRules = await analyzeConversation({
+                const { rules: newRules } = await generateRulesFromSession({
                     modelManager,
-                    messages: messageHistory.get(),
+                    messages: sessionManager.get(),
                     tokenTracker,
                     config,
                     workspace,
@@ -40,13 +38,13 @@ export const generateRulesCommand = ({ sessionManager: messageHistory, modelMana
                     }
                     else {
                         try {
-                            const existingRules = await config.readProjectLearnedRulesFile();
+                            const existingRules = await config.readLearnedRulesFile();
                             const rulesToAdd = selectedRules.join("\n");
-                            const updatedProjectRules = existingRules.endsWith("\n") || existingRules.length === 0
+                            const updatedRules = 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));
+                            await config.writeLearnedRulesFile(updatedRules);
+                            container.addChild(new Text(style.green("Selected rules saved to 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));
@@ -79,91 +77,6 @@ export const generateRulesCommand = ({ sessionManager: messageHistory, modelMana
         },
     };
 };
-async function analyzeConversation({ modelManager, messages, tokenTracker, config: configManager, workspace, }) {
-    const learnedRules = await configManager.readCachedLearnedRulesFile();
-    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 systemPromptText = await createSystemPrompt(configManager, workspace);
-    const { text, usage } = await generateText({
-        model: modelManager.getModel("conversation-analyzer"),
-        maxOutputTokens: 8192,
-        system: systemPromptText,
-        messages: messages,
-    });
-    tokenTracker.trackUsage("conversation-analyzer", usage);
-    const potentialRulesText = text.trim();
-    if (!potentialRulesText || potentialRulesText.length === 0) {
-        return [];
-    }
-    const potentialRulesList = potentialRulesText
-        .split("\n")
-        .map((rule) => rule.trim())
-        .filter((rule) => rule.length > 0);
-    if (potentialRulesList.length === 0) {
-        return [];
-    }
-    const updatedRules = learnedRules.endsWith("\n") || learnedRules.length === 0
-        ? `${learnedRules}${potentialRulesList.join("\n")}`
-        : `${learnedRules}\n${potentialRulesList.join("\n")}`;
-    await configManager.writeCachedLearnedRulesFile(updatedRules);
-    return potentialRulesList;
-}
-async function createSystemPrompt(configManager, workspace) {
-    const projectConfig = await configManager.getConfig();
-    const sys = await systemPrompt({
-        activeTools: projectConfig.tools.activeTools,
-        includeRules: true,
-        allowedDirs: workspace.allowedDirs,
-    });
-    return `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>
-${sys}
-</systemPrompt>`;
-}
 class RuleSelectorComponent extends Container {
     searchInput;
     listContainer;
@@ -246,12 +159,15 @@ class RuleSelectorComponent extends Container {
             this.listContainer.addChild(new Text(style.gray("  No matching rules"), 0, 0));
         }
     }
+    wantsNavigationKeys() {
+        return true;
+    }
     handleInput(keyData) {
-        if (isArrowUp(keyData)) {
+        if (isArrowUp(keyData) || isShiftTab(keyData)) {
             this.selectedIndex = Math.max(0, this.selectedIndex - 1);
             this.updateList();
         }
-        else if (isArrowDown(keyData)) {
+        else if (isArrowDown(keyData) || isTab(keyData)) {
             this.selectedIndex = Math.min(this.filteredRules.length - 1, this.selectedIndex + 1);
             this.updateList();
         }

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

@@ -0,0 +1,21 @@
+import { type ModelMessage } from "ai";
+import type { ConfigManager } from "../../config/index.ts";
+import type { WorkspaceContext } from "../../index.ts";
+import type { ModelManager } from "../../models/manager.ts";
+import type { TokenTracker } from "../../tokens/tracker.ts";
+export interface GenerateRulesOptions {
+    modelManager: ModelManager;
+    messages: ModelMessage[];
+    tokenTracker: TokenTracker;
+    config: ConfigManager;
+    workspace: WorkspaceContext;
+}
+export interface GenerateRulesResult {
+    rules: string[];
+}
+/**
+ * Analyzes conversation and generates rules without UI interaction.
+ * Returns the list of generated rules.
+ */
+export declare function generateRulesFromSession(options: GenerateRulesOptions): Promise<GenerateRulesResult>;
+//# sourceMappingURL=service.d.ts.map