phaibel 4.0.7

package/dist/commands/todo.js

@@ -0,0 +1,678 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { promises as fs } from 'fs';
+import path from 'path';
+import matter from 'gray-matter';
+import { getVaultRoot } from '../state/manager.js';
+import { getEnrichedContext } from '../context/reader.js';
+import { getModelForCapability, createSystemPrompt } from '../llm/router.js';
+import { getResponse } from '../responses.js';
+import { renderEntityHeader, entityPrompt, todoHeaderConfig } from '../ui/entity-prompt.js';
+import { pushCrumb, popCrumb } from '../ui/breadcrumb.js';
+import { debug } from '../utils/debug.js';
+import { listEntities } from './list.js';
+import { getEntityIndex } from '../entities/entity-index.js';
+import { findEntityByTitle, trashEntity, generateEntityId, entityFilename } from '../entities/entity.js';
+async function findExistingTodo(titleOrFilename) {
+    const found = await findEntityByTitle('task', titleOrFilename);
+    if (!found)
+        return null;
+    return {
+        filepath: found.filepath,
+        title: found.meta.title,
+        content: found.content,
+        priority: found.meta.priority || 'medium',
+        dueDate: found.meta.dueDate,
+        completed: found.meta.status === 'done',
+    };
+}
+async function breakdownTodo(state) {
+    console.log(chalk.gray('\n' + getResponse('todo_breakdown')));
+    const context = await getEnrichedContext('todos', state.content);
+    const llm = await getModelForCapability('reason');
+    const systemPrompt = createSystemPrompt(context);
+    const response = await llm.chat([
+        {
+            role: 'user',
+            content: `Break down the following todo into smaller, actionable subtasks. Format as a markdown checklist with [ ] for each item. Keep each subtask specific and achievable.
+
+Title: ${state.title}
+
+Current Content:
+${state.content || '(No details yet)'}`,
+        },
+    ], { systemPrompt });
+    // Strip code fences if present
+    let formatted = response.trim();
+    if (formatted.startsWith('```markdown')) {
+        formatted = formatted.slice(11);
+    }
+    else if (formatted.startsWith('```')) {
+        formatted = formatted.slice(3);
+    }
+    if (formatted.endsWith('```')) {
+        formatted = formatted.slice(0, -3);
+    }
+    return formatted.trim();
+}
+async function clarifyTodo(state) {
+    console.log(chalk.gray('\n' + getResponse('processing')));
+    const context = await getEnrichedContext('todos', state.content);
+    const llm = await getModelForCapability('reason');
+    const systemPrompt = createSystemPrompt(context);
+    const response = await llm.chat([
+        {
+            role: 'user',
+            content: `Review and clarify the following todo. Make the description clearer, add context if helpful, and ensure the goal is specific and measurable. Return ONLY the improved content, no explanations.
+
+Title: ${state.title}
+Priority: ${state.priority}
+${state.dueDate ? `Due: ${state.dueDate}` : ''}
+
+Content:
+${state.content || '(No details yet)'}`,
+        },
+    ], { systemPrompt });
+    // Strip code fences if present
+    let formatted = response.trim();
+    if (formatted.startsWith('```markdown')) {
+        formatted = formatted.slice(11);
+    }
+    else if (formatted.startsWith('```')) {
+        formatted = formatted.slice(3);
+    }
+    if (formatted.endsWith('```')) {
+        formatted = formatted.slice(0, -3);
+    }
+    return formatted.trim();
+}
+async function estimateTodo(state) {
+    console.log(chalk.gray('\n' + getResponse('thinking')));
+    const context = await getEnrichedContext('todos', state.content);
+    const llm = await getModelForCapability('reason');
+    const systemPrompt = createSystemPrompt(context);
+    const response = await llm.chat([
+        {
+            role: 'user',
+            content: `Analyze the following todo and provide:
+1. Time estimate (how long it will take)
+2. Complexity rating (simple/moderate/complex)
+3. Dependencies (what needs to be done first)
+4. Suggested priority based on the content
+
+Keep the analysis brief and actionable.
+
+Title: ${state.title}
+Current Priority: ${state.priority}
+${state.dueDate ? `Due: ${state.dueDate}` : ''}
+
+Content:
+${state.content || '(No details yet)'}`,
+        },
+    ], { systemPrompt });
+    return response.trim();
+}
+async function modifyTodo(state, feedback) {
+    console.log(chalk.gray('\n' + getResponse('processing')));
+    const context = await getEnrichedContext('todos', state.content);
+    const llm = await getModelForCapability('reason');
+    const systemPrompt = createSystemPrompt(context);
+    const response = await llm.chat([
+        {
+            role: 'user',
+            content: `Modify the following todo based on the user's feedback. Return ONLY the modified content, no explanations.
+
+Title: ${state.title}
+
+Current Content:
+${state.content || '(No details yet)'}
+
+User Feedback: ${feedback}`,
+        },
+    ], { systemPrompt });
+    // Strip code fences if present
+    let formatted = response.trim();
+    if (formatted.startsWith('```markdown')) {
+        formatted = formatted.slice(11);
+    }
+    else if (formatted.startsWith('```')) {
+        formatted = formatted.slice(3);
+    }
+    if (formatted.endsWith('```')) {
+        formatted = formatted.slice(0, -3);
+    }
+    return formatted.trim();
+}
+async function formatTodo(state) {
+    console.log(chalk.gray('\n' + getResponse('processing')));
+    try {
+        const context = await getEnrichedContext('todos', state.content);
+        const llm = await getModelForCapability('format');
+        const systemPrompt = createSystemPrompt(context);
+        const response = await llm.chat([
+            {
+                role: 'user',
+                content: `Format the following todo content as clean, well-structured markdown. Use appropriate headers, lists, and emphasis. Keep all information intact.
+
+IMPORTANT: Return ONLY the raw markdown content. Do NOT wrap in code fences.
+
+Title: ${state.title}
+
+Content:
+${state.content}`,
+            },
+        ], { systemPrompt });
+        // Strip code fences if present
+        let formatted = response.trim();
+        if (formatted.startsWith('```markdown')) {
+            formatted = formatted.slice(11);
+        }
+        else if (formatted.startsWith('```md')) {
+            formatted = formatted.slice(5);
+        }
+        else if (formatted.startsWith('```')) {
+            formatted = formatted.slice(3);
+        }
+        if (formatted.endsWith('```')) {
+            formatted = formatted.slice(0, -3);
+        }
+        return formatted.trim();
+    }
+    catch (err) {
+        debug('todo', err);
+        console.log(chalk.yellow('Formatting skipped (configure AI for formatting)'));
+        return state.content;
+    }
+}
+async function saveTodo(state) {
+    const vaultRoot = await getVaultRoot();
+    const todosDir = path.join(vaultRoot, 'todos');
+    // Ensure todos directory exists
+    await fs.mkdir(todosDir, { recursive: true });
+    // Use existing filepath or create new one
+    let filepath = state.filepath;
+    let entityId;
+    if (filepath) {
+        // Editing — read id from existing frontmatter
+        const raw = await fs.readFile(filepath, 'utf-8');
+        const parsed = matter(raw);
+        entityId = parsed.data.id ?? path.basename(filepath, '.md');
+    }
+    else {
+        entityId = generateEntityId('task');
+        filepath = path.join(todosDir, entityFilename(state.title, entityId));
+    }
+    // Format content before saving
+    const finalContent = await formatTodo(state);
+    // Create markdown with frontmatter
+    const today = new Date().toISOString().split('T')[0];
+    const markdown = `---
+id: ${entityId}
+title: "${state.title}"
+created: ${today}
+priority: ${state.priority}
+${state.dueDate ? `dueDate: ${state.dueDate}` : ''}
+completed: ${state.completed}
+tags: [todo]
+---
+
+${finalContent}
+`;
+    await fs.writeFile(filepath, markdown);
+    // Update entity index
+    const index = getEntityIndex();
+    if (index.isBuilt) {
+        await index.addOrUpdate('task', entityId, state.title, filepath);
+    }
+    return filepath;
+}
+function displayTodo(state) {
+    const priorityColors = {
+        low: chalk.gray,
+        medium: chalk.yellow,
+        high: chalk.red,
+    };
+    const priorityColor = priorityColors[state.priority];
+    const statusIcon = state.completed ? '✅' : '⬜';
+    console.log(chalk.cyan('\n' + '─'.repeat(50)));
+    console.log(`${statusIcon} ${chalk.bold.cyan(state.title)} ${priorityColor(`[${state.priority}]`)}`);
+    if (state.dueDate) {
+        console.log(chalk.gray(`   Due: ${state.dueDate}`));
+    }
+    console.log(chalk.cyan('─'.repeat(50)));
+    console.log(state.content || chalk.gray('(No details yet)'));
+    console.log(chalk.cyan('─'.repeat(50) + '\n'));
+}
+function showHelp() {
+    console.log(chalk.gray(`
+Commands:
+  ${chalk.bold('breakdown')}  - AI breaks the todo into subtasks
+  ${chalk.bold('clarify')}    - AI clarifies and improves the description
+  ${chalk.bold('estimate')}   - AI estimates time, complexity, dependencies
+  ${chalk.bold('modify')}     - AI modifies the todo based on your feedback
+  ${chalk.bold('save')}       - Save the current version
+  ${chalk.bold('show')}       - Display the current todo
+  ${chalk.bold('edit')}       - Edit the todo content
+  ${chalk.bold('title')}      - Change the title
+  ${chalk.bold('priority')}   - Set priority (low|medium|high)
+  ${chalk.bold('due')}        - Set due date
+  ${chalk.bold('done')}       - Mark as completed
+  ${chalk.bold('exit')}       - Save and go back
+  ${chalk.bold('back')}       - Save and go back
+  ${chalk.bold('abort')}      - Discard changes and go back
+  ${chalk.bold('quit')}       - Quit entirely
+  ${chalk.bold('help')}       - Show this help
+`));
+}
+export const todoCommand = new Command('todo')
+    .description('Interactive todo management with AI assistance')
+    .argument('[words...]', 'Title and optional inline description (e.g. "fix-login The login 500s with plus signs")')
+    .action(async (words) => {
+    try {
+        // Handle: todo list
+        if (words[0] === 'list') {
+            await listEntities('todos');
+            return;
+        }
+        // Handle: todo done <title>
+        if (words[0] === 'done') {
+            const doneTitle = words.slice(1).join(' ');
+            if (!doneTitle) {
+                console.log(chalk.yellow('\n  Please specify which task to complete: todo done <title>\n'));
+                return;
+            }
+            const existing = await findExistingTodo(doneTitle);
+            if (!existing) {
+                console.log(chalk.red(`\n  ✗ Task "${doneTitle}" not found\n`));
+                return;
+            }
+            const doneState = {
+                title: existing.title,
+                content: existing.content,
+                priority: existing.priority,
+                dueDate: existing.dueDate,
+                filepath: existing.filepath,
+                isExisting: true,
+                completed: true,
+            };
+            const filepath = await saveTodo(doneState);
+            const msg = getResponse('task_complete');
+            console.log(chalk.green(`\n  ✓ ${msg}`));
+            console.log(chalk.gray(`    ${filepath}\n`));
+            return;
+        }
+        // Handle: todo remove <title>
+        if (words[0] === 'remove' || words[0] === 'delete') {
+            const removeTitle = words.slice(1).join(' ');
+            if (!removeTitle) {
+                console.log(chalk.yellow('\n  Please specify which task to remove: todo remove <title>\n'));
+                return;
+            }
+            const existing = await findExistingTodo(removeTitle);
+            if (!existing) {
+                console.log(chalk.red(`\n  ✗ Task "${removeTitle}" not found\n`));
+                return;
+            }
+            // Read id from frontmatter before trashing
+            const raw = await fs.readFile(existing.filepath, 'utf-8');
+            const taskId = matter(raw).data.id ?? path.basename(existing.filepath, '.md');
+            const trashPath = await trashEntity(existing.filepath);
+            // Update entity index
+            const idx = getEntityIndex();
+            if (idx.isBuilt) {
+                idx.remove('task', taskId);
+            }
+            console.log(chalk.green(`\n  🗑  Moved to trash: ${existing.title}`));
+            console.log(chalk.gray(`    ${trashPath}\n`));
+            return;
+        }
+        // Parse: first word = title, rest = inline description
+        let title = words.length > 0 ? words[0] : undefined;
+        const inlineBody = words.length > 1 ? words.slice(1).join(' ') : undefined;
+        // Get title if not provided
+        if (!title) {
+            const { todoTitle } = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'todoTitle',
+                    message: 'What task should be tracked?',
+                    validate: (input) => input.length > 0 || 'Title is required',
+                },
+            ]);
+            title = todoTitle;
+        }
+        // Check if todo already exists
+        const existing = await findExistingTodo(title);
+        let state;
+        if (existing) {
+            // Open existing todo — if inline body, append to it
+            if (inlineBody) {
+                const updatedContent = existing.content
+                    ? existing.content + '\n\n' + inlineBody
+                    : inlineBody;
+                state = {
+                    title: existing.title,
+                    content: updatedContent,
+                    priority: existing.priority,
+                    dueDate: existing.dueDate,
+                    filepath: existing.filepath,
+                    isExisting: true,
+                    completed: existing.completed,
+                };
+                const filepath = await saveTodo(state);
+                console.log(chalk.green(`\n✓ Appended to "${existing.title}" → ${filepath}`));
+                return;
+            }
+            console.log(chalk.green(`\n✓ Opening existing todo "${existing.title}"`));
+            state = {
+                title: existing.title,
+                content: existing.content,
+                priority: existing.priority,
+                dueDate: existing.dueDate,
+                filepath: existing.filepath,
+                isExisting: true,
+                completed: existing.completed,
+            };
+        }
+        else if (inlineBody) {
+            // Quick todo — save immediately with medium priority
+            state = {
+                title: title,
+                content: inlineBody,
+                priority: 'medium',
+                dueDate: undefined,
+                isExisting: false,
+                completed: false,
+            };
+            const filepath = await saveTodo(state);
+            console.log(chalk.green(`\n✓ Quick todo saved → ${filepath}`));
+            return;
+        }
+        else {
+            // Create new todo - get initial details
+            const { priority } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'priority',
+                    message: 'Priority level?',
+                    choices: [
+                        { name: 'Low', value: 'low' },
+                        { name: 'Medium', value: 'medium' },
+                        { name: 'High', value: 'high' },
+                    ],
+                    default: 'medium',
+                },
+            ]);
+            const { dueDate } = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'dueDate',
+                    message: 'Due date (YYYY-MM-DD, or leave empty):',
+                    validate: (input) => {
+                        if (!input)
+                            return true;
+                        return /^\d{4}-\d{2}-\d{2}$/.test(input) || 'Use format YYYY-MM-DD';
+                    },
+                },
+            ]);
+            const { content } = await inquirer.prompt([
+                {
+                    type: 'editor',
+                    name: 'content',
+                    message: 'Todo details (optional):',
+                },
+            ]);
+            state = {
+                title: title,
+                content: content.trim(),
+                priority,
+                dueDate: dueDate || undefined,
+                isExisting: false,
+                completed: false,
+            };
+            console.log(chalk.green(`\n✓ Todo created`));
+        }
+        pushCrumb('todo');
+        renderEntityHeader(todoHeaderConfig(state));
+        showHelp();
+        displayTodo(state);
+        // Interactive loop
+        let running = true;
+        while (running) {
+            const { command } = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'command',
+                    message: entityPrompt('todo'),
+                    prefix: '',
+                },
+            ]);
+            const cmd = command.trim().toLowerCase();
+            const parts = cmd.split(' ');
+            const action = parts[0];
+            const args = parts.slice(1).join(' ');
+            switch (action) {
+                case 'save': {
+                    const filepath = await saveTodo(state);
+                    console.log(chalk.green(`\n✓ Todo saved to ${filepath}, sir!`));
+                    break;
+                }
+                case 'exit': {
+                    const filepath = await saveTodo(state);
+                    console.log(chalk.green(`\n✓ Todo saved to ${filepath}, sir!`));
+                    running = false;
+                    break;
+                }
+                case 'back':
+                case 'b': {
+                    const filepath = await saveTodo(state);
+                    console.log(chalk.green(`\n✓ Todo saved to ${filepath}, sir!`));
+                    running = false;
+                    break;
+                }
+                case 'abort': {
+                    const { confirm } = await inquirer.prompt([
+                        {
+                            type: 'confirm',
+                            name: 'confirm',
+                            message: 'There is unsaved work. Discard changes?',
+                            default: false,
+                        },
+                    ]);
+                    if (confirm) {
+                        console.log(chalk.yellow(getResponse('task_discarded')));
+                        running = false;
+                    }
+                    break;
+                }
+                case 'quit':
+                case 'q': {
+                    const { confirm: quitConfirm } = await inquirer.prompt([
+                        {
+                            type: 'confirm',
+                            name: 'confirm',
+                            message: 'There is unsaved work. Quit entirely?',
+                            default: false,
+                        },
+                    ]);
+                    if (quitConfirm) {
+                        console.log(chalk.yellow(getResponse('farewell')));
+                        process.exit(42);
+                    }
+                    break;
+                }
+                case 'breakdown': {
+                    try {
+                        const breakdown = await breakdownTodo(state);
+                        state.content = state.content ? state.content + '\n\n## Subtasks\n\n' + breakdown : breakdown;
+                        console.log(chalk.green('✓ Todo broken down into subtasks!'));
+                        displayTodo(state);
+                    }
+                    catch (error) {
+                        console.error(chalk.red('Error breaking down todo:'), error);
+                    }
+                    break;
+                }
+                case 'clarify': {
+                    try {
+                        state.content = await clarifyTodo(state);
+                        console.log(chalk.green('✓ Todo clarified!'));
+                        displayTodo(state);
+                    }
+                    catch (error) {
+                        console.error(chalk.red('Error clarifying todo:'), error);
+                    }
+                    break;
+                }
+                case 'estimate': {
+                    try {
+                        const estimate = await estimateTodo(state);
+                        console.log(chalk.cyan('\n📊 Estimate:\n'));
+                        console.log(estimate);
+                        console.log('');
+                    }
+                    catch (error) {
+                        console.error(chalk.red('Error estimating todo:'), error);
+                    }
+                    break;
+                }
+                case 'modify': {
+                    if (!args) {
+                        const { feedback } = await inquirer.prompt([
+                            {
+                                type: 'input',
+                                name: 'feedback',
+                                message: 'How should the todo be modified?',
+                            },
+                        ]);
+                        if (feedback) {
+                            try {
+                                state.content = await modifyTodo(state, feedback);
+                                console.log(chalk.green('✓ Todo modified!'));
+                                displayTodo(state);
+                            }
+                            catch (error) {
+                                console.error(chalk.red('Error modifying todo:'), error);
+                            }
+                        }
+                    }
+                    else {
+                        try {
+                            state.content = await modifyTodo(state, args);
+                            console.log(chalk.green('✓ Todo modified!'));
+                            displayTodo(state);
+                        }
+                        catch (error) {
+                            console.error(chalk.red('Error modifying todo:'), error);
+                        }
+                    }
+                    break;
+                }
+                case 'show': {
+                    displayTodo(state);
+                    break;
+                }
+                case 'edit': {
+                    const { newContent } = await inquirer.prompt([
+                        {
+                            type: 'editor',
+                            name: 'newContent',
+                            message: 'Edit todo:',
+                            default: state.content,
+                        },
+                    ]);
+                    state.content = newContent.trim();
+                    console.log(chalk.green('✓ Todo updated!'));
+                    displayTodo(state);
+                    break;
+                }
+                case 'title': {
+                    const { newTitle } = await inquirer.prompt([
+                        {
+                            type: 'input',
+                            name: 'newTitle',
+                            message: 'New title:',
+                            default: state.title,
+                        },
+                    ]);
+                    state.title = newTitle;
+                    console.log(chalk.green(`✓ Title changed to "${newTitle}"`));
+                    break;
+                }
+                case 'priority': {
+                    const newPriority = args;
+                    if (['low', 'medium', 'high'].includes(newPriority)) {
+                        state.priority = newPriority;
+                        console.log(chalk.green(`✓ Priority set to ${newPriority}`));
+                    }
+                    else {
+                        const { selectedPriority } = await inquirer.prompt([
+                            {
+                                type: 'list',
+                                name: 'selectedPriority',
+                                message: 'Select priority:',
+                                choices: ['low', 'medium', 'high'],
+                                default: state.priority,
+                            },
+                        ]);
+                        state.priority = selectedPriority;
+                        console.log(chalk.green(`✓ Priority set to ${selectedPriority}`));
+                    }
+                    displayTodo(state);
+                    break;
+                }
+                case 'due': {
+                    if (args && /^\d{4}-\d{2}-\d{2}$/.test(args)) {
+                        state.dueDate = args;
+                        console.log(chalk.green(`✓ Due date set to ${args}`));
+                    }
+                    else {
+                        const { newDueDate } = await inquirer.prompt([
+                            {
+                                type: 'input',
+                                name: 'newDueDate',
+                                message: 'Due date (YYYY-MM-DD):',
+                                default: state.dueDate || '',
+                                validate: (input) => {
+                                    if (!input)
+                                        return true;
+                                    return /^\d{4}-\d{2}-\d{2}$/.test(input) || 'Use format YYYY-MM-DD';
+                                },
+                            },
+                        ]);
+                        state.dueDate = newDueDate || undefined;
+                        console.log(chalk.green(newDueDate ? `✓ Due date set to ${newDueDate}` : '✓ Due date cleared'));
+                    }
+                    displayTodo(state);
+                    break;
+                }
+                case 'done': {
+                    state.completed = !state.completed;
+                    console.log(chalk.green(state.completed ? '✓ Marked as completed!' : '✓ Marked as incomplete'));
+                    displayTodo(state);
+                    break;
+                }
+                case 'help':
+                case '?': {
+                    showHelp();
+                    break;
+                }
+                case '': {
+                    // Empty command, ignore
+                    break;
+                }
+                default: {
+                    console.log(chalk.yellow(`Unknown command: ${action}. Type 'help' for options.`));
+                    break;
+                }
+            }
+        }
+        popCrumb();
+    }
+    catch (error) {
+        console.error(chalk.red(getResponse('error')), error);
+    }
+});
+export default todoCommand;
+//# sourceMappingURL=todo.js.map