@travisennis/acai 0.0.7 → 0.0.8

package/dist/commands/pickup/index.js

@@ -0,0 +1,138 @@
+import { getTerminalSize, isArrowDown, isArrowUp, isEnter, isEscape, } from "../../terminal/control.js";
+import style from "../../terminal/style.js";
+import { Input, Spacer, Text, Container as TuiContainer, } from "../../tui/index.js";
+import { getAvailableHandoffFiles, hidePickupSelector, loadHandoff, } from "./utils.js";
+export const pickupCommand = (options) => {
+    return {
+        command: "/pickup",
+        description: "Loads a handoff file into a new session to continue previous work. Usage: /pickup",
+        getSubCommands: () => Promise.resolve([]),
+        async handle(_args, { tui, container, inputContainer, editor, }) {
+            const handoffs = await getAvailableHandoffFiles();
+            if (handoffs.length === 0) {
+                container.addChild(new Text(style.yellow("No handoff files found."), 0, 1));
+                container.addChild(new Text("Create a handoff file first using /handoff <purpose>", 1, 0));
+                tui.requestRender();
+                editor.setText("");
+                return "continue";
+            }
+            const handoffSelector = new HandoffSelectorComponent(handoffs, async (handoff) => {
+                await loadHandoff(handoff, options, container, tui, editor);
+                hidePickupSelector(inputContainer, editor, tui);
+            }, () => {
+                hidePickupSelector(inputContainer, editor, tui);
+            });
+            inputContainer.clear();
+            inputContainer.addChild(handoffSelector);
+            tui.setFocus(handoffSelector);
+            tui.requestRender();
+            return "continue";
+        },
+    };
+};
+class HandoffSelectorComponent extends TuiContainer {
+    searchInput;
+    listContainer;
+    allHandoffs = [];
+    filteredHandoffs = [];
+    selectedIndex = 0;
+    onSelectCallback;
+    onCancelCallback;
+    constructor(handoffs, onSelect, onCancel) {
+        super();
+        this.onSelectCallback = onSelect;
+        this.onCancelCallback = onCancel;
+        this.allHandoffs = handoffs;
+        this.filteredHandoffs = handoffs;
+        const { columns } = getTerminalSize();
+        this.addChild(new Text(style.blue("─".repeat(columns)), 0, 0));
+        this.addChild(new Spacer(1));
+        this.searchInput = new Input();
+        this.searchInput.onSubmit = () => {
+            const handoff = this.filteredHandoffs[this.selectedIndex];
+            if (handoff !== undefined) {
+                this.handleSelect(handoff);
+            }
+        };
+        this.addChild(this.searchInput);
+        this.addChild(new Spacer(1));
+        this.listContainer = new TuiContainer();
+        this.addChild(this.listContainer);
+        this.addChild(new Spacer(1));
+        this.addChild(new Text(style.blue("─".repeat(columns)), 0, 0));
+        this.updateList();
+    }
+    filterHandoffs(query) {
+        if (!query.trim()) {
+            this.filteredHandoffs = this.allHandoffs;
+        }
+        else {
+            const searchTokens = query
+                .toLowerCase()
+                .split(/\s+/)
+                .filter((t) => t);
+            this.filteredHandoffs = this.allHandoffs.filter((handoff) => {
+                const searchText = handoff.name.toLowerCase();
+                return searchTokens.every((token) => searchText.includes(token));
+            });
+        }
+        this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, this.filteredHandoffs.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.filteredHandoffs.length - maxVisible));
+        const endIndex = Math.min(startIndex + maxVisible, this.filteredHandoffs.length);
+        for (let i = startIndex; i < endIndex; i++) {
+            const handoff = this.filteredHandoffs[i];
+            if (handoff === undefined)
+                continue;
+            const isSelected = i === this.selectedIndex;
+            let line = "";
+            if (isSelected) {
+                const prefix = style.blue("→ ");
+                const date = handoff.createdAt.toLocaleString();
+                line = `${prefix + style.blue(handoff.name)} ${style.gray(`(${date})`)}`;
+            }
+            else {
+                const date = handoff.createdAt.toLocaleString();
+                line = `  ${handoff.name} ${style.gray(`(${date})`)}`;
+            }
+            this.listContainer.addChild(new Text(line, 0, 0));
+        }
+        if (startIndex > 0 || endIndex < this.filteredHandoffs.length) {
+            const scrollInfo = style.gray(`  (${this.selectedIndex + 1}/${this.filteredHandoffs.length})`);
+            this.listContainer.addChild(new Text(scrollInfo, 0, 0));
+        }
+        if (this.filteredHandoffs.length === 0) {
+            this.listContainer.addChild(new Text(style.gray("  No matching handoffs"), 0, 0));
+        }
+    }
+    handleInput(keyData) {
+        if (isArrowUp(keyData)) {
+            this.selectedIndex = Math.max(0, this.selectedIndex - 1);
+            this.updateList();
+        }
+        else if (isArrowDown(keyData)) {
+            this.selectedIndex = Math.min(this.filteredHandoffs.length - 1, this.selectedIndex + 1);
+            this.updateList();
+        }
+        else if (isEnter(keyData)) {
+            const selectedHandoff = this.filteredHandoffs[this.selectedIndex];
+            if (selectedHandoff !== undefined) {
+                this.handleSelect(selectedHandoff);
+            }
+        }
+        else if (isEscape(keyData)) {
+            this.onCancelCallback();
+        }
+        else {
+            this.searchInput.handleInput(keyData);
+            this.filterHandoffs(this.searchInput.getValue());
+        }
+    }
+    handleSelect(handoff) {
+        this.onSelectCallback(handoff);
+    }
+}

package/dist/commands/pickup/types.d.ts

@@ -0,0 +1,6 @@
+export interface HandoffFile {
+    name: string;
+    filename: string;
+    createdAt: Date;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/commands/pickup/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../source/commands/pickup/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,IAAI,CAAC;CACjB"}

package/dist/commands/pickup/types.js

@@ -0,0 +1 @@
+export {};

package/dist/commands/pickup/utils.d.ts

@@ -0,0 +1,7 @@
+import type { Container, Editor, TUI } from "../../tui/index.ts";
+import type { CommandOptions } from "../types.ts";
+import type { HandoffFile } from "./types.ts";
+export declare function hidePickupSelector(editorContainer: Container, editor: Editor, tui: TUI): void;
+export declare function getAvailableHandoffFiles(): Promise<HandoffFile[]>;
+export declare function loadHandoff(handoff: HandoffFile, options: CommandOptions, container: Container, tui: TUI, editor: Editor): Promise<void>;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../source/commands/pickup/utils.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,oBAAoB,CAAC;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,wBAAgB,kBAAkB,CAChC,eAAe,EAAE,SAAS,EAC1B,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,GAAG,GACP,IAAI,CAIN;AAED,wBAAsB,wBAAwB,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC,CA4BvE;AAED,wBAAsB,WAAW,CAC/B,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,cAAc,EACvB,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC,CA8Cf"}

package/dist/commands/pickup/utils.js

@@ -0,0 +1,56 @@
+import { readFile } from "node:fs/promises";
+import { basename } from "node:path";
+import { createUserMessage } from "../../sessions/manager.js";
+export function hidePickupSelector(editorContainer, editor, tui) {
+    editorContainer.clear();
+    editorContainer.addChild(editor);
+    tui.setFocus(editor);
+}
+export async function getAvailableHandoffFiles() {
+    const handoffsDir = ".acai/handoffs";
+    try {
+        const { readdir, stat } = await import("node:fs/promises");
+        const dirents = await readdir(handoffsDir, {
+            withFileTypes: true,
+        });
+        const files = [];
+        for (const dirent of dirents) {
+            if (dirent.isFile() && dirent.name.match(/^handoff-.*\.md$/)) {
+                const filepath = `${handoffsDir}/${dirent.name}`;
+                const stats = await stat(filepath);
+                files.push({
+                    name: basename(dirent.name, ".md"),
+                    filename: dirent.name,
+                    createdAt: stats.mtime,
+                });
+            }
+        }
+        files.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+        return files;
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return [];
+        }
+        return [];
+    }
+}
+export async function loadHandoff(handoff, options, container, tui, editor) {
+    const { sessionManager: messageHistory, modelManager } = options;
+    const filepath = `.acai/handoffs/${handoff.filename}`;
+    try {
+        const handoffContent = await readFile(filepath, "utf8");
+        container.addChild(new (await import("../../tui/index.js")).Text(`Loading handoff: ${(await import("../../terminal/style.js")).default.blue(handoff.name)}`, 0, 1));
+        messageHistory.create(modelManager.getModel("repl").modelId);
+        messageHistory.appendUserMessage(createUserMessage([], handoffContent));
+        container.addChild(new (await import("../../tui/index.js")).Text("Handoff loaded successfully.", 1, 0));
+        container.addChild(new (await import("../../tui/index.js")).Text("You can now continue with your previous work.", 2, 0));
+        tui.requestRender();
+        editor.setText("");
+    }
+    catch (error) {
+        container.addChild(new (await import("../../tui/index.js")).Text(`Error loading handoff: ${error}`, 0, 1));
+        tui.requestRender();
+        editor.setText("");
+    }
+}

package/dist/commands/prompt/index.d.ts

@@ -0,0 +1,5 @@
+import type { CommandOptions, ReplCommand } from "../types.ts";
+import type { PromptMetadata } from "./types.ts";
+export declare function loadPrompts(config: CommandOptions["config"]): Promise<Map<string, PromptMetadata>>;
+export declare const promptCommand: ({ modelManager, promptManager, config, promptHistory, workspace, }: CommandOptions) => ReplCommand;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/prompt/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../source/commands/prompt/index.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAOjD,wBAAsB,WAAW,CAAC,MAAM,EAAE,cAAc,CAAC,QAAQ,CAAC,wCA0DjE;AAED,eAAO,MAAM,aAAa,GAAI,oEAM3B,cAAc,KAAG,WAuHnB,CAAC"}

package/dist/commands/prompt/index.js

@@ -0,0 +1,126 @@
+import { readdir, readFile } from "node:fs/promises";
+import path, { basename } from "node:path";
+import { logger } from "../../logger.js";
+import { processPrompt } from "../../mentions.js";
+import style from "../../terminal/style.js";
+import { Spacer, Text } from "../../tui/index.js";
+import { findPrompt, parsePromptFile, replaceArgumentPlaceholders, } from "./utils.js";
+export async function loadPrompts(config) {
+    const getPromptsFromDir = async (dirPath, type) => {
+        try {
+            const dirents = await readdir(dirPath, { withFileTypes: true });
+            const mdFiles = dirents.filter((dirent) => dirent.isFile() && dirent.name.endsWith(".md"));
+            const prompts = [];
+            for (const dirent of mdFiles) {
+                const filePath = path.join(dirPath, dirent.name);
+                try {
+                    const content = await readFile(filePath, "utf8");
+                    const parsed = parsePromptFile(content);
+                    if (parsed.metadata.enabled) {
+                        prompts.push({
+                            name: basename(dirent.name, ".md"),
+                            description: parsed.metadata.description,
+                            enabled: parsed.metadata.enabled,
+                            path: filePath,
+                            type,
+                        });
+                    }
+                }
+                catch (error) {
+                    logger.error(`Error reading prompt file ${filePath}: ${error}`);
+                }
+            }
+            return prompts;
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return [];
+            }
+            logger.error(`Error reading prompts from ${dirPath}: ${error}`);
+            return [];
+        }
+    };
+    const userPromptDir = config.app.getPath("prompts");
+    const projectPromptDir = config.project.getPath("prompts");
+    const userPrompts = await getPromptsFromDir(userPromptDir, "user");
+    const projectPrompts = await getPromptsFromDir(projectPromptDir, "project");
+    const promptMap = new Map();
+    for (const prompt of userPrompts) {
+        promptMap.set(prompt.name, prompt);
+    }
+    for (const prompt of projectPrompts) {
+        promptMap.set(prompt.name, prompt);
+    }
+    return promptMap;
+}
+export const promptCommand = ({ modelManager, promptManager, config, promptHistory, workspace, }) => {
+    return {
+        command: "/prompt",
+        description: "Loads and executes prompts. Project prompts override user prompts with the same name.",
+        getSubCommands: async () => {
+            const promptMap = await loadPrompts(config);
+            const promptList = Array.from(promptMap.values())
+                .map((p) => p.name)
+                .sort();
+            return promptList;
+        },
+        async handle(args, { tui, container, editor, }) {
+            const promptName = args?.[0];
+            if (!promptName) {
+                container.addChild(new Text(style.red("No prompt given."), 1, 0));
+                tui.requestRender();
+                editor.setText("");
+                return "continue";
+            }
+            try {
+                const promptResult = await findPrompt(promptName, config);
+                if (!promptResult) {
+                    container.addChild(new Text(style.red(`Prompt not found: ${promptName}. Available prompts can be seen with tab completion.`), 1, 0));
+                    tui.requestRender();
+                    editor.setText("");
+                    return "continue";
+                }
+                let promptContent;
+                try {
+                    const fileContent = await readFile(promptResult.path, "utf8");
+                    const parsed = parsePromptFile(fileContent);
+                    promptContent = parsed.content;
+                }
+                catch (error) {
+                    if (error.code === "ENOENT") {
+                        container.addChild(new Text(style.red(`Prompt file not found: ${promptName} at ${promptResult.path}`), 1, 0));
+                        tui.requestRender();
+                        editor.setText("");
+                        return "continue";
+                    }
+                    throw error;
+                }
+                const inputArgs = args.slice(1);
+                promptContent = replaceArgumentPlaceholders(promptContent, inputArgs);
+                container.addChild(new Spacer(1));
+                container.addChild(new Text(`Loaded ${promptResult.type} prompt: ${style.blue(promptName)}`, 1, 0));
+                if (inputArgs.length > 0) {
+                    container.addChild(new Text(`Input: "${inputArgs.join(" ")}"`, 2, 0));
+                }
+                const processedPrompt = await processPrompt(promptContent.trim(), {
+                    baseDir: workspace.primaryDir,
+                    model: modelManager.getModelMetadata("repl"),
+                });
+                for (const context of processedPrompt.context) {
+                    promptManager.addContext(context);
+                }
+                promptManager.set(processedPrompt.message);
+                promptHistory.push(processedPrompt.message);
+                tui.requestRender();
+                editor.setText("");
+                return "use";
+            }
+            catch (error) {
+                container.addChild(new Text(style.red(`Error loading prompt: ${error.message}`), 1, 0));
+                tui.requestRender();
+                editor.setText("");
+                return "continue";
+            }
+        },
+    };
+};

package/dist/commands/prompt/types.d.ts

@@ -0,0 +1,15 @@
+export interface PromptMetadata {
+    name: string;
+    description: string;
+    enabled: boolean;
+    path: string;
+    type: "project" | "user";
+}
+export interface ParsedPrompt {
+    content: string;
+    metadata: {
+        description: string;
+        enabled: boolean;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/commands/prompt/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../source/commands/prompt/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,SAAS,GAAG,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE;QACR,WAAW,EAAE,MAAM,CAAC;QACpB,OAAO,EAAE,OAAO,CAAC;KAClB,CAAC;CACH"}

package/dist/commands/prompt/types.js

@@ -0,0 +1 @@
+export {};

package/dist/commands/prompt/utils.d.ts

@@ -0,0 +1,12 @@
+import type { ConfigManager } from "../../config.ts";
+import type { PromptMetadata } from "./types.ts";
+export declare function replaceArgumentPlaceholders(content: string, args: string[]): string;
+export declare function parsePromptFile(content: string): {
+    content: string;
+    metadata: {
+        description: string;
+        enabled: boolean;
+    };
+};
+export declare function findPrompt(promptName: string, config: ConfigManager): Promise<PromptMetadata | null>;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../source/commands/prompt/utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,GACb,MAAM,CA6BR;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG;IAChD,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE;QACR,WAAW,EAAE,MAAM,CAAC;QACpB,OAAO,EAAE,OAAO,CAAC;KAClB,CAAC;CACH,CA4CA;AAED,wBAAsB,UAAU,CAC9B,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAoDhC"}

package/dist/commands/prompt/utils.js

@@ -0,0 +1,107 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+export function replaceArgumentPlaceholders(content, args) {
+    const allArguments = args.join(" ");
+    let replacementsMade = false;
+    let result = content;
+    for (let i = 0; i < args.length; i++) {
+        const placeholder = `$${i + 1}`;
+        if (result.includes(placeholder)) {
+            result = result.replaceAll(placeholder, args[i]);
+            replacementsMade = true;
+        }
+    }
+    if (result.includes("$ARGUMENTS")) {
+        result = result.replaceAll("$ARGUMENTS", allArguments);
+        replacementsMade = true;
+    }
+    if (result.includes("{{INPUT}}")) {
+        result = result.replaceAll("{{INPUT}}", allArguments);
+        replacementsMade = true;
+    }
+    if (!replacementsMade && allArguments.trim().length > 0) {
+        result += `\n\n${allArguments}`;
+    }
+    return result;
+}
+export function parsePromptFile(content) {
+    const frontMatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*(?:\n([\s\S]*))?$/);
+    if (!frontMatterMatch) {
+        return {
+            content,
+            metadata: {
+                description: content.split("\n")[0].trim().slice(0, 50) +
+                    (content.split("\n")[0].trim().length > 50 ? "..." : ""),
+                enabled: true,
+            },
+        };
+    }
+    const yamlContent = frontMatterMatch[1];
+    const promptContent = frontMatterMatch[2] || "";
+    const defaultDescription = promptContent.split("\n")[0].trim().slice(0, 50) +
+        (promptContent.split("\n")[0].trim().length > 50 ? "..." : "");
+    let description = defaultDescription;
+    let enabled = true;
+    const descriptionMatch = yamlContent.match(/^description:\s*(.+)$/m);
+    if (descriptionMatch) {
+        description = descriptionMatch[1].trim();
+    }
+    const enabledMatch = yamlContent.match(/^enabled:\s*(true|false)$/im);
+    if (enabledMatch) {
+        enabled = enabledMatch[1].toLowerCase() === "true";
+    }
+    return {
+        content: promptContent,
+        metadata: {
+            description,
+            enabled,
+        },
+    };
+}
+export async function findPrompt(promptName, config) {
+    const projectPromptDir = config.project.getPath("prompts");
+    const projectPath = path.join(projectPromptDir, `${promptName}.md`);
+    if (config.project.existsSync("prompts")) {
+        try {
+            const content = await readFile(projectPath, "utf8");
+            const parsed = parsePromptFile(content);
+            if (!parsed.metadata.enabled) {
+                return null;
+            }
+            return {
+                name: promptName,
+                description: parsed.metadata.description,
+                enabled: parsed.metadata.enabled,
+                path: projectPath,
+                type: "project",
+            };
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+    }
+    const userPromptDir = config.app.getPath("prompts");
+    const userPath = path.join(userPromptDir, `${promptName}.md`);
+    try {
+        const content = await readFile(userPath, "utf8");
+        const parsed = parsePromptFile(content);
+        if (!parsed.metadata.enabled) {
+            return null;
+        }
+        return {
+            name: promptName,
+            description: parsed.metadata.description,
+            enabled: parsed.metadata.enabled,
+            path: userPath,
+            type: "user",
+        };
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+    }
+    return null;
+}

package/dist/commands/remove-directory/index.d.ts

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

package/dist/commands/remove-directory/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../source/commands/remove-directory/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/D,eAAO,MAAM,sBAAsB,GAAI,gBAEpC,cAAc,KAAG,WAkGnB,CAAC"}

package/dist/commands/{remove-directory-command.js → remove-directory/index.js}

@@ -1,6 +1,6 @@
 import path from "node:path";
-import style from "../terminal/style.js";
-import { Text } from "../tui/index.js";
+import style from "../../terminal/style.js";
+import { Text } from "../../tui/index.js";
 export const removeDirectoryCommand = ({ workspace, }) => {
     return {
         command: "/remove-directory",

package/dist/commands/reset/index.d.ts

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

package/dist/commands/reset/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../source/commands/reset/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/D,eAAO,MAAM,YAAY,GAAI,mDAG1B,cAAc,KAAG,WAsCnB,CAAC"}

package/dist/commands/{reset-command.js → reset/index.js}

@@ -1,5 +1,5 @@
-import { setTerminalTitle } from "../terminal/formatting.js";
-export const resetCommand = ({ modelManager, messageHistory, }) => {
+import { setTerminalTitle } from "../../terminal/control.js";
+export const resetCommand = ({ modelManager, sessionManager: messageHistory, }) => {
     return {
         command: "/reset",
         aliases: ["/new"],
@@ -13,6 +13,11 @@ export const resetCommand = ({ modelManager, messageHistory, }) => {
             setTerminalTitle(`acai: ${process.cwd()}`);
             container.clear();
             editor.setText("");
+            // Reset footer state to clear usage/cost/steps/tools/time
+            const footer = tui.children.find((child) => child.constructor.name === "FooterComponent");
+            if (footer) {
+                footer.resetState();
+            }
             tui.requestRender();
             return "continue";
         },

package/dist/commands/reset/types.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=types.d.ts.map

package/dist/commands/reset/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../source/commands/reset/types.ts"],"names":[],"mappings":""}

package/dist/commands/reset/types.js

@@ -0,0 +1,3 @@
+"use strict";
+// Types for reset command
+// Currently no specific types needed beyond the base CommandOptions

package/dist/commands/resources/index.d.ts

@@ -0,0 +1,3 @@
+import type { CommandOptions, ReplCommand } from "../types.ts";
+export declare function resourcesCommand(options: CommandOptions): ReplCommand;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/resources/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../source/commands/resources/index.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/D,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,cAAc,GAAG,WAAW,CA6GrE"}

package/dist/commands/resources/index.js

@@ -0,0 +1,84 @@
+import { loadSkills } from "../../skills.js";
+import style from "../../terminal/style.js";
+import { Modal, Container as ModalContainer, ModalText, } from "../../tui/index.js";
+export function resourcesCommand(options) {
+    return {
+        command: "/resources",
+        description: "List all active skills and AGENTS.md",
+        aliases: ["/res"],
+        getSubCommands: async () => [],
+        async handle(_args, { tui, editor }) {
+            try {
+                const skills = await loadSkills();
+                const agentsFiles = await options.config.readAgentsFiles();
+                const projectSkills = skills.filter((s) => s.source === "project");
+                const userSkills = skills.filter((s) => s.source === "user");
+                const otherSkills = skills.filter((s) => s.source !== "project" && s.source !== "user");
+                const lines = [];
+                if (projectSkills.length > 0) {
+                    lines.push(style.gray(`Project Skills (${projectSkills.length}):`));
+                    for (const skill of projectSkills) {
+                        lines.push(`${style.yellow.bold(skill.name)}
+${skill.description}
+${style.dim(skill.filePath)}
+`);
+                    }
+                    lines.push("");
+                }
+                if (userSkills.length > 0) {
+                    lines.push(style.gray(`User Skills (${userSkills.length}):`));
+                    for (const skill of userSkills) {
+                        lines.push(`${style.yellow.bold(skill.name)}
+${skill.description}
+${style.dim(skill.filePath)}
+`);
+                    }
+                    lines.push("");
+                }
+                if (otherSkills.length > 0) {
+                    lines.push(style.gray(`Other Skills (${otherSkills.length}):`));
+                    for (const skill of otherSkills) {
+                        lines.push(`${style.yellow.bold(skill.name)}
+${skill.description}
+${style.dim(skill.filePath)} ${style.dim(`[${skill.source}]`)}
+`);
+                    }
+                    lines.push("");
+                }
+                lines.push(style.gray("AGENTS.md:"));
+                for (const agentsFile of agentsFiles) {
+                    if (agentsFile.content.length > 0) {
+                        lines.push(`  • ${agentsFile.path} ${style.green("(Exists)")}`);
+                    }
+                    else {
+                        lines.push(`  • ${agentsFile.path} ${style.dim("(Not found)")}`);
+                    }
+                }
+                const modalContent = new ModalContainer();
+                const formattedText = lines.join("\n");
+                if (formattedText.trim()) {
+                    modalContent.addChild(new ModalText(formattedText, 0, 1));
+                }
+                else {
+                    modalContent.addChild(new ModalText("No resources found.", 0, 1));
+                }
+                const modal = new Modal("Active Resources", modalContent, true, () => {
+                    editor.setText("");
+                    tui.requestRender();
+                });
+                tui.showModal(modal);
+                return "continue";
+            }
+            catch (error) {
+                const errorContent = new ModalContainer();
+                errorContent.addChild(new ModalText(style.red(`Error loading resources: ${error.message}`), 0, 1));
+                const errorModal = new Modal("Error", errorContent, true, () => {
+                    editor.setText("");
+                    tui.requestRender();
+                });
+                tui.showModal(errorModal);
+                return "continue";
+            }
+        },
+    };
+}