@meltstudio/meltctl 2.4.1 → 4.0.0

package/dist/commands/project/clean.js

@@ -1,243 +0,0 @@
-import { intro, outro, confirm, spinner } from '@clack/prompts';
-import chalk from 'chalk';
-import fs from 'fs-extra';
-import path from 'path';
-// List of Melt-generated command files to remove
-const MELT_COMMAND_FILES = [
-    'melt-plan.md',
-    'melt-test-plan.md',
-    'melt-docs.md',
-    'melt-implement.md',
-    'melt-pr.md',
-    'melt-review.md',
-    'melt-complete.md',
-    'melt-debug.md',
-];
-export async function cleanCommand(options = {}) {
-    intro(chalk.blue('🧹 Melt Project - Clean'));
-    const currentDir = process.cwd();
-    const meltDir = path.join(currentDir, '.melt');
-    const cursorCommandsDir = path.join(currentDir, '.cursor', 'commands');
-    // Check if this is a Melt workspace
-    const hasMeltWorkspace = await fs.pathExists(meltDir);
-    const hasCursorCommands = await fs.pathExists(cursorCommandsDir);
-    if (!hasMeltWorkspace && !hasCursorCommands) {
-        console.log(chalk.yellow('⚠️  No Melt workspace found in this directory.'));
-        console.log("This project doesn't appear to have Melt tools installed.");
-        outro(chalk.gray('Nothing to clean.'));
-        return;
-    }
-    // Analyze what will be cleaned
-    const analysisResult = await analyzeCleanupTarget(currentDir);
-    if (analysisResult.removedFiles.length === 0 && analysisResult.removedDirs.length === 0) {
-        console.log(chalk.yellow('⚠️  No Melt files found to clean.'));
-        outro(chalk.gray('Nothing to clean.'));
-        return;
-    }
-    // Show what will be cleaned
-    displayCleanupPlan(analysisResult);
-    // Get confirmation (skip if --yes flag is provided)
-    let shouldProceed = options.yes || false;
-    if (!shouldProceed) {
-        const confirmResult = await confirm({
-            message: 'Do you want to proceed with cleaning? This action cannot be undone.',
-        });
-        if (confirmResult !== true) {
-            outro(chalk.gray('Clean operation cancelled.'));
-            return;
-        }
-        shouldProceed = true;
-    }
-    // Perform the cleanup
-    const s = spinner();
-    s.start('Cleaning Melt workspace...');
-    try {
-        const cleanResult = await performCleanup(currentDir);
-        s.stop('✅ Cleanup completed!');
-        displayCleanupResults(cleanResult);
-        outro(chalk.green('🎉 Melt workspace cleaned successfully!'));
-    }
-    catch (error) {
-        s.stop('❌ Cleanup failed');
-        console.error(chalk.red('Error during cleanup:'), error);
-        process.exit(1);
-    }
-}
-async function analyzeCleanupTarget(baseDir) {
-    const result = {
-        removedFiles: [],
-        removedDirs: [],
-        preservedFiles: [],
-        errors: [],
-    };
-    const meltDir = path.join(baseDir, '.melt');
-    const cursorCommandsDir = path.join(baseDir, '.cursor', 'commands');
-    try {
-        // Check .melt directory (remove entirely)
-        if (await fs.pathExists(meltDir)) {
-            result.removedDirs.push('.melt/');
-        }
-        // Check .cursor/commands directory (selective removal)
-        if (await fs.pathExists(cursorCommandsDir)) {
-            const commandFiles = await fs.readdir(cursorCommandsDir);
-            for (const file of commandFiles) {
-                const filePath = path.join(cursorCommandsDir, file);
-                const stat = await fs.stat(filePath);
-                if (stat.isFile()) {
-                    if (MELT_COMMAND_FILES.includes(file)) {
-                        result.removedFiles.push(path.join('.cursor/commands', file));
-                    }
-                    else {
-                        result.preservedFiles.push(path.join('.cursor/commands', file));
-                    }
-                }
-            }
-            // Check if .cursor/commands will be empty after cleaning
-            const meltFiles = commandFiles.filter(file => MELT_COMMAND_FILES.includes(file));
-            const nonMeltFiles = commandFiles.filter(file => !MELT_COMMAND_FILES.includes(file));
-            if (meltFiles.length > 0 && nonMeltFiles.length === 0) {
-                result.removedDirs.push('.cursor/commands/');
-                // Also check if .cursor itself would be empty
-                const cursorDir = path.join(baseDir, '.cursor');
-                const cursorContents = await fs.readdir(cursorDir);
-                if (cursorContents.length === 1 && cursorContents[0] === 'commands') {
-                    result.removedDirs.push('.cursor/');
-                }
-            }
-        }
-    }
-    catch (error) {
-        result.errors.push(`Failed to analyze cleanup target: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    return result;
-}
-async function performCleanup(baseDir) {
-    const result = {
-        removedFiles: [],
-        removedDirs: [],
-        preservedFiles: [],
-        errors: [],
-    };
-    const meltDir = path.join(baseDir, '.melt');
-    const cursorCommandsDir = path.join(baseDir, '.cursor', 'commands');
-    try {
-        // Remove .melt directory entirely
-        if (await fs.pathExists(meltDir)) {
-            await fs.remove(meltDir);
-            result.removedDirs.push('.melt/');
-        }
-        // Remove Melt command files from .cursor/commands
-        if (await fs.pathExists(cursorCommandsDir)) {
-            const commandFiles = await fs.readdir(cursorCommandsDir);
-            let hasNonMeltFiles = false;
-            for (const file of commandFiles) {
-                const filePath = path.join(cursorCommandsDir, file);
-                const stat = await fs.stat(filePath);
-                if (stat.isFile()) {
-                    if (MELT_COMMAND_FILES.includes(file)) {
-                        try {
-                            await fs.remove(filePath);
-                            result.removedFiles.push(path.join('.cursor/commands', file));
-                        }
-                        catch (error) {
-                            result.errors.push(`Failed to remove ${file}: ${error instanceof Error ? error.message : String(error)}`);
-                        }
-                    }
-                    else {
-                        hasNonMeltFiles = true;
-                        result.preservedFiles.push(path.join('.cursor/commands', file));
-                    }
-                }
-            }
-            // Remove empty directories if no user files remain
-            if (!hasNonMeltFiles) {
-                try {
-                    await fs.remove(cursorCommandsDir);
-                    result.removedDirs.push('.cursor/commands/');
-                    // Check if .cursor directory is now empty
-                    const cursorDir = path.join(baseDir, '.cursor');
-                    if (await fs.pathExists(cursorDir)) {
-                        const cursorContents = await fs.readdir(cursorDir);
-                        if (cursorContents.length === 0) {
-                            await fs.remove(cursorDir);
-                            result.removedDirs.push('.cursor/');
-                        }
-                    }
-                }
-                catch (error) {
-                    result.errors.push(`Failed to remove empty directories: ${error instanceof Error ? error.message : String(error)}`);
-                }
-            }
-        }
-    }
-    catch (error) {
-        result.errors.push(`Cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    return result;
-}
-function displayCleanupPlan(result) {
-    console.log();
-    console.log(chalk.cyan('📋 Cleanup Plan:'));
-    console.log();
-    if (result.removedDirs.length > 0) {
-        console.log(chalk.yellow('Directories to be removed:'));
-        result.removedDirs.forEach(dir => {
-            console.log(`  • ${chalk.red(dir)}`);
-        });
-        console.log();
-    }
-    if (result.removedFiles.length > 0) {
-        console.log(chalk.yellow('Files to be removed:'));
-        result.removedFiles.forEach(file => {
-            console.log(`  • ${chalk.red(file)}`);
-        });
-        console.log();
-    }
-    if (result.preservedFiles.length > 0) {
-        console.log(chalk.green('Files to be preserved:'));
-        result.preservedFiles.forEach(file => {
-            console.log(`  • ${chalk.cyan(file)}`);
-        });
-        console.log();
-    }
-    if (result.errors.length > 0) {
-        console.log(chalk.red('Analysis errors:'));
-        result.errors.forEach(error => {
-            console.log(`  ⚠️  ${error}`);
-        });
-        console.log();
-    }
-}
-function displayCleanupResults(result) {
-    console.log();
-    console.log(chalk.green('🎯 Cleanup Summary:'));
-    console.log();
-    if (result.removedDirs.length > 0) {
-        console.log(chalk.green(`✅ Removed ${result.removedDirs.length} directories:`));
-        result.removedDirs.forEach(dir => {
-            console.log(`   • ${dir}`);
-        });
-        console.log();
-    }
-    if (result.removedFiles.length > 0) {
-        console.log(chalk.green(`✅ Removed ${result.removedFiles.length} files:`));
-        result.removedFiles.forEach(file => {
-            console.log(`   • ${file}`);
-        });
-        console.log();
-    }
-    if (result.preservedFiles.length > 0) {
-        console.log(chalk.cyan(`🔒 Preserved ${result.preservedFiles.length} user files:`));
-        result.preservedFiles.forEach(file => {
-            console.log(`   • ${file}`);
-        });
-        console.log();
-    }
-    if (result.errors.length > 0) {
-        console.log(chalk.red(`❌ Errors encountered (${result.errors.length}):`));
-        result.errors.forEach(error => {
-            console.log(`   • ${error}`);
-        });
-        console.log();
-    }
-}

package/dist/commands/project/init.d.ts

@@ -1,5 +0,0 @@
-interface InitOptions {
-    shell?: 'sh' | 'ps' | 'auto';
-}
-export declare function initCommand(options?: InitOptions): Promise<void>;
-export {};

package/dist/commands/project/init.js

@@ -1,158 +0,0 @@
-import { intro, outro, select, confirm, spinner } from '@clack/prompts';
-import chalk from 'chalk';
-import { existsSync, readFileSync } from 'fs';
-import fs from 'fs-extra';
-import { join, dirname } from 'path';
-import { platform } from 'os';
-import { fileURLToPath } from 'url';
-const SHELL_CHOICES = {
-    sh: 'POSIX Shell (bash/zsh)',
-    ps: 'PowerShell',
-};
-export async function initCommand(options = {}) {
-    intro(chalk.blue('🚀 Melt Project - Initialize'));
-    const currentDir = process.cwd();
-    // Check if directories already exist
-    const cursorDir = join(currentDir, '.cursor', 'commands');
-    const meltDir = join(currentDir, '.melt');
-    const existingPaths = [];
-    if (existsSync(cursorDir))
-        existingPaths.push('.cursor/commands/');
-    if (existsSync(meltDir))
-        existingPaths.push('.melt/');
-    if (existingPaths.length > 0) {
-        console.log(chalk.yellow('⚠️  The following directories already exist:'));
-        existingPaths.forEach(path => console.log(`   • ${path}`));
-        console.log();
-        const shouldContinue = await confirm({
-            message: 'Do you want to continue? This may overwrite existing files.',
-        });
-        if (!shouldContinue) {
-            outro(chalk.gray('Operation cancelled.'));
-            return;
-        }
-    }
-    // Shell selection (explicit, auto-detect, or interactive)
-    let selectedShell;
-    if (options.shell && options.shell !== 'auto') {
-        selectedShell = options.shell;
-    }
-    else {
-        // Auto-detect based on platform
-        const defaultShell = platform() === 'win32' ? 'ps' : 'sh';
-        if (options.shell === 'auto') {
-            selectedShell = defaultShell;
-        }
-        else {
-            // Interactive selection with default
-            selectedShell = (await select({
-                message: 'Choose script type:',
-                options: [
-                    { value: 'sh', label: SHELL_CHOICES.sh, hint: defaultShell === 'sh' ? 'default' : '' },
-                    { value: 'ps', label: SHELL_CHOICES.ps, hint: defaultShell === 'ps' ? 'default' : '' },
-                ],
-                initialValue: defaultShell,
-            }));
-        }
-    }
-    console.log(chalk.cyan(`Selected shell: ${SHELL_CHOICES[selectedShell]}`));
-    console.log();
-    const s = spinner();
-    s.start('Setting up Melt development workspace...');
-    try {
-        // Create directory structures
-        createDirectoryStructure(currentDir, selectedShell);
-        // Copy templates
-        await copyTemplates(currentDir, selectedShell);
-        // Create version file
-        createVersionFile(meltDir);
-        s.stop('✅ Workspace setup complete!');
-        console.log();
-        console.log(chalk.green('🎉 Melt development workspace initialized!'));
-        console.log();
-        console.log('Created directories:');
-        console.log(`  • ${chalk.cyan('.cursor/commands/')}`);
-        console.log(`  • ${chalk.cyan('.melt/memory/')}`);
-        console.log(`  • ${chalk.cyan('.melt/outputs/plans/')}`);
-        console.log(`  • ${chalk.cyan('.melt/outputs/implementations/')}`);
-        console.log(`  • ${chalk.cyan('.melt/outputs/reviews/')}`);
-        console.log(`  • ${chalk.cyan('.melt/scripts/sh/')}`);
-        console.log(`  • ${chalk.cyan('.melt/scripts/ps/')}`);
-        console.log(`  • ${chalk.cyan('.melt/templates/')}`);
-        console.log();
-        console.log('Next steps:');
-        console.log('  1. Open Cursor IDE');
-        console.log(`  2. Run ${chalk.cyan('/melt-plan')} to start planning a feature`);
-        console.log('  3. Follow the workflow: Plan → Test → Implement → Review');
-        console.log();
-        console.log(`See docs: ${chalk.cyan('https://melt-development-prompts.vercel.app')}`);
-        outro(chalk.green('Happy coding with Melt! 🚀'));
-    }
-    catch (error) {
-        s.stop('❌ Setup failed');
-        console.error(chalk.red('Error during setup:'), error);
-        process.exit(1);
-    }
-}
-function createDirectoryStructure(baseDir, shell) {
-    const dirs = [
-        '.cursor/commands',
-        '.melt/memory',
-        '.melt/outputs/plans',
-        '.melt/outputs/implementations',
-        '.melt/outputs/reviews',
-        '.melt/scripts/sh',
-        '.melt/scripts/ps',
-        '.melt/templates',
-    ];
-    dirs.forEach(dir => {
-        const fullPath = join(baseDir, dir);
-        fs.ensureDirSync(fullPath);
-    });
-}
-async function copyTemplates(baseDir, shell) {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    // In dist, we need to go back to the CLI package root and find templates (from dist/commands/project to CLI root)
-    const templatesDir = join(__dirname, '../../../templates');
-    // Copy cursor commands
-    const cursorCommandsTemplateDir = join(templatesDir, 'cursor-commands');
-    const cursorCommandsDestDir = join(baseDir, '.cursor', 'commands');
-    if (existsSync(cursorCommandsTemplateDir)) {
-        fs.copySync(cursorCommandsTemplateDir, cursorCommandsDestDir);
-    }
-    // Create initial context file from memory
-    const contextSourcePath = join(__dirname, '../../../memory', 'context.md');
-    const contextDestPath = join(baseDir, '.melt', 'memory', 'context.md');
-    if (existsSync(contextSourcePath)) {
-        let contextContent = readFileSync(contextSourcePath, 'utf8');
-        // Replace timestamp placeholders
-        const timestamp = new Date().toISOString();
-        contextContent = contextContent.replace(/{{timestamp}}/g, timestamp);
-        fs.writeFileSync(contextDestPath, contextContent, 'utf8');
-    }
-    // Copy shell scripts from CLI package (copy both sh and ps scripts)
-    const scriptsBaseDir = join(__dirname, '../../../scripts');
-    const shellTypes = ['sh', 'ps'];
-    for (const shellType of shellTypes) {
-        const scriptsSourceDir = join(scriptsBaseDir, shellType);
-        const scriptsDestDir = join(baseDir, '.melt', 'scripts', shellType);
-        if (existsSync(scriptsSourceDir)) {
-            fs.copySync(scriptsSourceDir, scriptsDestDir);
-        }
-    }
-}
-function createVersionFile(meltDir) {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    // In dist, we need to go back to the CLI package root (from dist/commands/project to CLI root)
-    const packageJsonPath = join(__dirname, '../../../package.json');
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
-    const versionData = {
-        cliVersion: packageJson.version,
-        initialized: new Date().toISOString(),
-        lastUpdate: new Date().toISOString(),
-    };
-    const versionPath = join(meltDir, 'version.json');
-    fs.writeFileSync(versionPath, JSON.stringify(versionData, null, 2), 'utf8');
-}

package/dist/commands/project/update.d.ts

@@ -1 +0,0 @@
-export declare function updateCommand(): Promise<void>;

package/dist/commands/project/update.js

@@ -1,107 +0,0 @@
-import { intro, outro, spinner, confirm } from '@clack/prompts';
-import chalk from 'chalk';
-import { execSync } from 'child_process';
-import fs from 'fs-extra';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { getCurrentCliVersion, getLatestCliVersion, compareVersions, } from '../../utils/version-check.js';
-import { detectPackageManager } from '../../utils/package-manager.js';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-async function updateCliPackage() {
-    const s = spinner();
-    s.start('Updating @meltstudio/meltctl package...');
-    try {
-        const { updateCommand } = detectPackageManager();
-        execSync(updateCommand, {
-            stdio: 'pipe',
-        });
-        s.stop('CLI package updated successfully!');
-    }
-    catch (error) {
-        s.stop('Failed to update CLI package');
-        throw error;
-    }
-}
-async function updateCursorCommands() {
-    const s = spinner();
-    s.start('Updating .cursor/commands/ with latest prompts...');
-    try {
-        const templatesDir = path.join(__dirname, '../../../templates/cursor-commands');
-        const targetDir = path.join(process.cwd(), '.cursor', 'commands');
-        if (await fs.pathExists(templatesDir)) {
-            await fs.ensureDir(targetDir);
-            await fs.copy(templatesDir, targetDir, { overwrite: true });
-            s.stop('Cursor commands updated successfully!');
-        }
-        else {
-            s.stop('No cursor templates found to update');
-        }
-    }
-    catch (error) {
-        s.stop('Failed to update cursor commands');
-        throw error;
-    }
-}
-async function migrateMeltWorkspace() {
-    const s = spinner();
-    s.start('Checking .melt/ workspace migration...');
-    try {
-        const meltDir = path.join(process.cwd(), '.melt');
-        if (await fs.pathExists(meltDir)) {
-            s.stop('Melt workspace found - no migration needed');
-        }
-        else {
-            s.stop('No melt workspace found - consider running meltctl project init');
-        }
-    }
-    catch (error) {
-        s.stop('Failed to check melt workspace');
-        throw error;
-    }
-}
-export async function updateCommand() {
-    intro(chalk.blue('🔄 Melt Project - Update'));
-    try {
-        const currentVersion = await getCurrentCliVersion();
-        const latestVersion = await getLatestCliVersion();
-        if (!latestVersion) {
-            console.log(chalk.yellow('⚠️  Unable to check for updates (network error)'));
-            console.log(chalk.gray(`Current CLI version: ${currentVersion}`));
-            console.log();
-        }
-        else {
-            console.log(chalk.gray(`Current CLI version: ${currentVersion}`));
-            console.log(chalk.gray(`Latest CLI version: ${latestVersion}`));
-            console.log();
-            if (compareVersions(currentVersion, latestVersion)) {
-                console.log(chalk.yellow(`📦 New version available: ${latestVersion}`));
-                const shouldUpdate = await confirm({
-                    message: 'Would you like to update the CLI package?',
-                });
-                if (shouldUpdate) {
-                    await updateCliPackage();
-                    console.log();
-                }
-            }
-            else {
-                console.log(chalk.green('✅ CLI package is up to date'));
-                console.log();
-            }
-        }
-        const shouldUpdateCommands = await confirm({
-            message: 'Would you like to update .cursor/commands/ with latest prompts?',
-        });
-        if (shouldUpdateCommands) {
-            await updateCursorCommands();
-            console.log();
-        }
-        await migrateMeltWorkspace();
-        outro(chalk.green('✅ Update process completed!'));
-    }
-    catch (error) {
-        console.error();
-        console.error(chalk.red('❌ Update failed:'), error instanceof Error ? error.message : String(error));
-        outro(chalk.red('Update process failed'));
-        process.exit(1);
-    }
-}

package/templates/cursor-commands/melt-complete.md

@@ -1,55 +0,0 @@
----
-description: Complete story implementation, handle deployment, and update Linear status
----
-
-Complete the story implementation and handle all post-development tasks:
-
-1. **Verify Completion**:
-   - Read `.melt/outputs/plans/` to check all planned tasks completed
-   - Review `.melt/outputs/implementations/` for implementation status
-   - Ensure all tests pass and coverage targets met
-   - Verify documentation is updated and accurate
-
-2. **Linear Story Update**:
-   - Update Linear story status to "Ready for Review" or "Complete"
-   - Add implementation notes and links to PR
-   - Update story with actual effort vs. estimated effort
-   - Link any follow-up stories or technical debt identified
-
-3. **Deployment Process**:
-   - Verify PR is approved and merged
-   - Monitor deployment pipeline for success
-   - Validate feature works in staging/production
-   - Check monitoring and logging for any issues
-
-4. **Feature Validation**:
-   - Test feature functionality end-to-end
-   - Verify acceptance criteria are fully met
-   - Check performance metrics if applicable
-   - Validate accessibility compliance
-
-5. **Documentation & Handoff**:
-   - Ensure user-facing documentation is updated
-   - Share feature with stakeholders if needed
-   - Document any lessons learned or technical debt
-   - Update architectural decision records if applicable
-
-6. **Cleanup Tasks**:
-   - Remove feature flags if no longer needed
-   - Archive implementation planning materials
-   - Update project roadmap or backlog
-   - Share knowledge with team members
-
-7. **Post-Completion Analysis**:
-   - Document actual vs. estimated effort
-   - Note any process improvements identified
-   - Record architectural patterns that worked well
-   - Identify any technical debt for future sprints
-
-8. **Save Completion Records**:
-   - Update Linear story with final status and notes
-   - Save completion summary to `.melt/outputs/implementations/[timestamp]-complete.md`
-   - Update `.melt/memory/context.md` with completion details
-   - Archive relevant planning and implementation files
-
-Focus on thorough validation and knowledge capture for continuous improvement.

package/templates/cursor-commands/melt-debug.md

@@ -1,43 +0,0 @@
----
-description: Debug issues using systematic approach and Melt development patterns
----
-
-Debug the issue systematically following our structured approach:
-
-1. **Issue Analysis**:
-   - Document the problem clearly in `.melt/memory/context.md`
-   - Identify affected domains and components
-   - Gather error messages, stack traces, and reproduction steps
-   - Check recent changes in `.melt/outputs/implementations/`
-
-2. **Domain-Specific Debugging**:
-   - Review component hierarchy and props flow
-   - Check custom hooks for state management issues
-   - Validate service layer API calls and data transformation
-   - Examine TypeScript types and Zod schema validation
-
-3. **Tool-Assisted Debugging**:
-   - Use React DevTools for component inspection
-   - Leverage TypeScript compiler for type checking
-   - Check browser console for runtime errors
-   - Use network tab for API debugging
-
-4. **Testing & Validation**:
-   - Run existing tests to identify regression
-   - Write minimal reproduction test case
-   - Check test coverage for the affected area
-   - Validate fix with comprehensive testing
-
-5. **Root Cause Analysis**:
-   - Document the underlying cause
-   - Identify if it's architectural, implementation, or configuration
-   - Check if similar issues exist elsewhere
-   - Plan preventive measures
-
-6. **Resolution Documentation**:
-   - Save debug session to `.melt/outputs/implementations/[timestamp]-debug.md`
-   - Update context with lessons learned
-   - Document any architectural improvements needed
-   - Share findings with team if applicable
-
-Remember: Focus on understanding the problem deeply before implementing solutions.

package/templates/cursor-commands/melt-docs.md

@@ -1,44 +0,0 @@
----
-description: Update project documentation and README based on implementation changes
----
-
-Update project documentation to reflect implementation changes and maintain accuracy:
-
-1. **Analyze Changes**:
-   - Review recent implementation in `.melt/outputs/implementations/`
-   - Check `.melt/outputs/plans/` for planned changes
-   - Identify new features, APIs, or architectural changes
-   - Review `.melt/memory/context.md` for context
-
-2. **Documentation Updates**:
-   - **README.md**: Update installation, usage, and examples
-   - **API Documentation**: Document new endpoints or changed interfaces
-   - **Component Documentation**: Add JSDoc comments and usage examples
-   - **Architecture Docs**: Update domain structure if changed
-   - **Deployment Docs**: Update if new environment variables or configs added
-
-3. **Documentation Patterns**:
-   - Use clear, concise language focused on developers
-   - Include code examples for new features
-   - Document breaking changes and migration steps
-   - Add troubleshooting sections for common issues
-   - Include links to relevant domain documentation
-
-4. **Code Documentation**:
-   - Add/update JSDoc comments for public APIs
-   - Document complex business logic with inline comments
-   - Update TypeScript interfaces with proper descriptions
-   - Ensure prop types are documented for components
-
-5. **Validation**:
-   - Verify all links work correctly
-   - Test code examples to ensure they're accurate
-   - Check that documentation matches actual implementation
-   - Ensure consistent formatting and style
-
-6. **Save Documentation Updates**:
-   - Update relevant documentation files
-   - Save documentation notes to `.melt/outputs/implementations/[timestamp]-docs.md`
-   - Update `.melt/memory/context.md` with documentation decisions
-
-Focus on keeping documentation current, accurate, and developer-focused.