@travisennis/acai 0.0.5 → 0.0.7

package/dist/commands/files-command.js

@@ -1,36 +1,36 @@
 import { readFile } from "node:fs/promises";
 import { formatFile } from "../formatting.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, }) => {
+export const filesCommand = ({ 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",
         getSubCommands: () => Promise.resolve([]),
-        execute: async (args) => {
+        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 });
-                    const selectedFiles = await checkbox({
-                        message: "Select files to include:",
-                        choices: foundFiles,
-                        pageSize: 15,
-                    });
-                    if (selectedFiles.length === 0) {
-                        terminal.warn("No files selected.");
+                    // 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";
                     }
-                    // Process the selected files
-                    workingFiles = selectedFiles;
                 }
                 else {
                     const patternList = args.filter(Boolean);
                     const foundFiles = await glob(patternList, { gitignore: true });
                     if (foundFiles.length === 0) {
-                        terminal.warn("No files found matching the pattern(s)");
+                        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
@@ -48,15 +48,19 @@ export const filesCommand = ({ terminal, promptManager, modelManager, }) => {
                         promptManager.addContext(formattedFile);
                     }
                     catch (error) {
-                        terminal.error(`Error reading file ${filePath}: ${error.message}`);
+                        container.addChild(new Text(style.red(`Error reading file ${filePath}: ${error.message}`), 1, 0));
                     }
                 }));
                 tokenCounter.free();
-                terminal.success(`File contents will be added to your next prompt (${workingFiles.length} files, ${tokenCount} tokens)`);
+                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) {
-                terminal.error(`Error processing file patterns: ${error.message}`);
+                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,3 +1,3 @@
 import type { CommandOptions, ReplCommand } from "./types.ts";
-export declare const generateRulesCommand: ({ terminal, messageHistory, modelManager, tokenTracker, config, }: CommandOptions) => ReplCommand;
+export declare const generateRulesCommand: ({ messageHistory, modelManager, tokenTracker, config, workspace, }: CommandOptions) => ReplCommand;
 //# sourceMappingURL=generate-rules-command.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"generate-rules-command.d.ts","sourceRoot":"","sources":["../../source/commands/generate-rules-command.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAuC9D,eAAO,MAAM,oBAAoB,GAAI,mEAMlC,cAAc,KAAG,WAmCnB,CAAC"}
+{"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;AAE9D,eAAO,MAAM,oBAAoB,GAAI,oEAMlC,cAAc,KAAG,WAoInB,CAAC"}

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

@@ -1,62 +1,330 @@
-import { analyzeConversation } from "../conversation-analyzer.js";
+import { generateText } from "ai";
+import { config } from "../config.js";
 import { logger } from "../logger.js"; // Import logger
-import { checkbox } from "../terminal/checkbox-prompt.js";
-async function _processAndSaveRules(newRules, terminal, config) {
-    if (!newRules || newRules.length === 0) {
-        terminal.warn("No new generalizable rules were identified.");
-        return;
-    }
-    terminal.info("Generated potential rules:");
-    terminal.lineBreak();
-    const rulesToKeep = await checkbox({
-        message: "Select the rules you want to keep:",
-        choices: newRules.map((rule) => ({ name: rule, value: rule })),
-    });
-    if (rulesToKeep.length === 0) {
-        terminal.warn("No rules selected to save.");
-        return;
-    }
-    terminal.info("Saving selected rules...");
-    const existingRules = await config.readProjectLearnedRulesFile();
-    const rulesToAdd = rulesToKeep.join("\n");
-    const updatedProjectRules = existingRules.endsWith("\n") || existingRules.length === 0
-        ? `${existingRules}${rulesToAdd}`
-        : `${existingRules}\n${rulesToAdd}`;
-    await config.writeProjectLearnedRulesFile(updatedProjectRules);
-    terminal.success("Selected rules saved to project learned rules.");
-    terminal.lineBreak();
-    terminal.display(rulesToAdd); // Display only the saved rules
-}
-export const generateRulesCommand = ({ terminal, messageHistory, modelManager, tokenTracker, config, // This is the config module from CommandOptions
- }) => {
+import { createUserMessage } from "../messages.js";
+import { systemPrompt } from "../prompts.js";
+import { getTerminalSize } from "../terminal/formatting.js";
+import style from "../terminal/style.js";
+import { Container, Input, Spacer, Text, } from "../tui/index.js";
+export const generateRulesCommand = ({ messageHistory, modelManager, tokenTracker, config, // This is the config module from CommandOptions
+workspace, }) => {
     return {
         command: "/generate-rules",
         description: "Analyzes the current conversation to generate and save new interaction rules, then displays them.",
         getSubCommands: () => Promise.resolve([]),
-        execute: async () => {
+        async handle(_args, { tui, container, inputContainer, editor, }) {
             if (messageHistory.isEmpty()) {
-                terminal.writeln("Cannot generate rules from an empty conversation.");
+                container.addChild(new Text(style.yellow("Cannot generate rules from an empty conversation."), 1, 0));
+                tui.requestRender();
+                editor.setText("");
                 return "continue";
             }
-            terminal.lineBreak();
-            terminal.info("Analyzing conversation to generate rules...");
+            container.addChild(new Text("Analyzing conversation to generate rules...", 0, 1));
+            tui.requestRender();
             try {
                 const newRules = await analyzeConversation({
                     modelManager,
                     messages: messageHistory.get(),
                     tokenTracker,
-                    terminal,
+                    config,
+                    workspace,
+                });
+                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();
                 });
-                // Pass the config object available in CommandOptions scope
-                await _processAndSaveRules(newRules, terminal, config);
+                // 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);
-                terminal.error(`Error generating rules: ${errorMessage}`);
+                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";
             }
-            return "continue";
         },
     };
 };
+// Modified System Prompt
+const system = async (configManager, workspace) => {
+    const projectConfig = await configManager.getConfig();
+    const sys = await systemPrompt({
+        type: projectConfig.systemPromptType,
+        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>`;
+};
+async function analyzeConversation({ modelManager, messages, tokenTracker, config: configManager, workspace, }) {
+    const learnedRules = await configManager.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(configManager, workspace),
+        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,WAoDxD,CAAC"}

package/dist/commands/handoff-command.js

@@ -0,0 +1,191 @@
+import { generateText } from "ai";
+import style from "../terminal/style.js";
+import { initCliTools } from "../tools/index.js";
+import { Text } from "../tui/index.js";
+export const handoffCommand = (options) => {
+    return {
+        command: "/handoff",
+        description: "Creates a detailed handoff plan of the conversation for continuing the work in a new session. Usage: /handoff <the purpose of the handoff>",
+        getSubCommands: () => Promise.resolve([]),
+        async handle(args, { tui, container, editor, }) {
+            // Validate that purpose is provided
+            const purpose = args.join(" ").trim();
+            if (!purpose) {
+                container.addChild(new Text(style.red("Please provide a purpose for the handoff. Usage: /handoff <the purpose of the handoff>"), 1, 0));
+                tui.requestRender();
+                editor.setText("");
+                return "continue";
+            }
+            container.addChild(new Text(`Creating handoff document for purpose: ${style.blue(purpose)}`, 1, 0));
+            tui.requestRender();
+            await createHandoffDocument(options, purpose);
+            container.addChild(new Text(style.green("Handoff document created"), 2, 0));
+            tui.requestRender();
+            editor.setText("");
+            return "continue";
+        },
+    };
+};
+const handoffPrompt = (purpose) => {
+    return `Creates a detailed handoff plan of the conversation for continuing the work in a new session.
+
+The user specified purpose:
+
+<purpose>${purpose}</purpose>
+
+You are creating a summary specifically so that it can be continued by another agent.  For this to work you MUST have a purpose.  If no specified purpose was provided in the \`<purpose>...</purpose>\` tag you must STOP IMMEDIATELY and ask the user what the purpose is.
+
+Do not continue before asking for the purpose as you will otherwise not understand the instructions and do not assume a purpose!
+
+## Goal
+
+Your task is to create a detailed summary of the conversation so far, paying close attention to the user's explicit purpose for the next steps.
+This handoff plan should be thorough in capturing technical details, code patterns, and architectural decisions that will be essential for continuing development work without losing context.
+
+## Process
+
+Before providing your final plan, wrap your analysis in <analysis> tags to organize your thoughts and ensure you've covered all necessary points. In your analysis process:
+
+1. Chronologically analyze each message and section of the conversation. For each section thoroughly identify:
+   - The user's explicit requests and intents
+   - Your approach to addressing the user's requests
+   - Key decisions, technical concepts and code patterns
+   - Specific details like file names, full code snippets, function signatures, file edits, etc
+2. Double-check for technical accuracy and completeness, addressing each required element thoroughly.
+
+Your plan should include the following sections:
+
+1. **Primary Request and Intent**: Capture all of the user's explicit requests and intents in detail
+2. **Key Technical Concepts**: List all important technical concepts, technologies, and frameworks discussed.
+3. **Files and Code Sections**: Enumerate specific files and code sections examined, modified, or created. Pay special attention to the most recent messages and include full code snippets where applicable and include a summary of why this file read or edit is important.
+4. **Problem Solving**: Document problems solved and any ongoing troubleshooting efforts.
+5. **Pending Tasks**: Outline any pending tasks that you have explicitly been asked to work on.
+6. **Current Work**: Describe in detail precisely what was being worked on immediately before this handoff request, paying special attention to the most recent messages from both user and assistant. Include file names and code snippets where applicable.
+7. **Optional Next Step**: List the next step that you will take that is related to the most recent work you were doing. IMPORTANT: ensure that this step is DIRECTLY in line with the user's explicit requests, and the task you were working on immediately before this handoff request. If your last task was concluded, then only list next steps if they are explicitly in line with the users request. Do not start on tangential requests without confirming with the user first.
+
+Additionally create a "slug" for this handoff.  The "slug" is how we will refer to it later in a few places.  Examples:
+
+* current-user-api-handler
+* implement-auth
+* fix-issue-42
+
+Together with the slug create a "Readable Summary".  Examples:
+
+* Implement Currnet User API Handler
+* Implement Authentication
+* Fix Issue #42
+
+## Output Structure
+
+Here's an example of how your output should be structured:
+
+\`\`\` markdown
+# Readable Summary
+
+<analysis>
+[Your thought process, ensuring all points are covered thoroughly and accurately]
+</analysis>
+
+<plan>
+# Session Handoff Plan
+
+## 1. Primary Request and Intent
+[Detailed description of all user requests and intents]
+
+## 2. Key Technical Concepts
+- [Concept 1]
+- [Concept 2]
+- [...]
+
+## 3. Files and Code Sections
+### [File Name 1]
+- **Why important**: [Summary of why this file is important]
+- **Changes made**: [Summary of the changes made to this file, if any]
+- **Code snippet**:
+\`\`\` language
+[Important Code Snippet]
+\`\`\`
+
+### [File Name 2]
+- **Code snippet**:
+\`\`\` language
+[Important Code Snippet]
+\`\`\`
+
+[...]
+
+## 4. Problem Solving
+[Description of solved problems and ongoing troubleshooting]
+
+## 5. Next Step
+[Required next step to take, directly aligned with user's explicit handoff purpose]
+</plan>
+\`\`\`
+
+## Final Step
+
+After providing your analysis and summary, write the handoff summary to a markdown file at \`handoff-[timestamp]-[slug].md\` where [timestamp] is the current date in format YYYY-MM-DD and the slug is what we defined before.
+
+Then tell the user about this file and that they can use \`/pickup FILENAME\` to continue.`;
+};
+async function createHandoffDocument({ modelManager, tokenTracker, tokenCounter, workspace }, purpose) {
+    const app = "handoff-agent";
+    const { text, usage } = await generateText({
+        model: modelManager.getModel(app),
+        system: "You are a helpful AI assistant tasked with creating detailed handoff summaries for coding agents. Focus on technical accuracy and completeness so that another agent can seamlessly continue the work.",
+        prompt: handoffPrompt(purpose),
+        tools: (await initCliTools({ tokenCounter, workspace })).toolDefs,
+    });
+    tokenTracker.trackUsage(app, usage);
+    console.info(text);
+    //   // Parse the response to extract the readable summary and slug
+    //   const lines = text.split("\n");
+    //   let readableSummary = "";
+    //   let slug = "";
+    //   const planContent = text;
+    //   // Extract readable summary (first heading after markdown)
+    //   for (let i = 0; i < lines.length; i++) {
+    //     const line = lines[i].trim();
+    //     if (line.startsWith("# ") && !readableSummary) {
+    //       readableSummary = line.substring(2).trim();
+    //       break;
+    //     }
+    //   }
+    //   // Create slug from readable summary
+    //   if (readableSummary) {
+    //     slug = readableSummary
+    //       .toLowerCase()
+    //       .replace(/[^a-z0-9\s-]/g, "")
+    //       .replace(/\s+/g, "-")
+    //       .replace(/-+/g, "-")
+    //       .trim();
+    //   }
+    //   // Generate filename with timestamp
+    //   const now = new Date();
+    //   const timestamp = now.toISOString().split("T")[0]; // YYYY-MM-DD format
+    //   const filename = `handoff-${timestamp}-${slug || "session"}.md`;
+    //   // Create the final handoff document
+    //   const handoffDocument = `# ${readableSummary || "Session Handoff"}
+    // ${planContent}
+    // ---
+    // *Generated on ${now.toISOString()} for purpose: ${purpose}*
+    // *This handoff file can be used to continue the work using the /pickup command*`;
+    //   // Save the handoff document using the saveFile tool
+    //   const saveFileTool = await createSaveFileTool({
+    //     workingDir: workspace.primaryDir,
+    //     allowedDirs: workspace.allowedDirs,
+    //   });
+    //   saveFileTool.execute(
+    //     {
+    //       path: `./${filename}`,
+    //       content: handoffDocument,
+    //       encoding: "utf-8",
+    //     },
+    //     {
+    //       toolCallId: `handoff-${Date.now()}`,
+    //       abortSignal: undefined,
+    //       messages: messageHistory.get(),
+    //     },
+    //   );
+    // console.info(`Handoff document created: ${filename}`);
+}

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

@@ -1,4 +1,4 @@
 import { execSync } from "node:child_process";
 import type { CommandOptions, ReplCommand } from "./types.ts";
-export declare function healthCommand({ terminal }: CommandOptions, execFn?: typeof execSync): ReplCommand;
+export declare function healthCommand(_options: CommandOptions, execFn?: typeof execSync): ReplCommand;
 //# sourceMappingURL=health-command.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"health-command.d.ts","sourceRoot":"","sources":["../../source/commands/health-command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9D,wBAAgB,aAAa,CAC3B,EAAE,QAAQ,EAAE,EAAE,cAAc,EAC5B,MAAM,kBAAW,GAChB,WAAW,CAqHb"}
+{"version":3,"file":"health-command.d.ts","sourceRoot":"","sources":["../../source/commands/health-command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAI9C,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9D,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,cAAc,EACxB,MAAM,kBAAW,GAChB,WAAW,CAiKb"}