explorbot 0.1.9 → 0.1.11

package/dist/src/commands/add-rule-command.js

@@ -3,11 +3,12 @@ import { join } from 'node:path';
 import { render } from 'ink';
 import React from 'react';
 import { tag } from '../utils/logger.js';
+import { printNextSteps, relativeToCwd } from "../utils/next-steps.js";
 import { BaseCommand } from './base-command.js';
 export class AddRuleCommand extends BaseCommand {
     name = 'add-rule';
     description = 'Create a rule file for an agent';
-    suggestions = ['/add-rule researcher check-tooltips'];
+    suggestions = [{ command: 'add-rule researcher check-tooltips', hint: 'example — add a rule for the researcher agent' }];
     async execute(args) {
         const parts = args.trim().split(/\s+/);
         const agentName = parts[0] || '';
@@ -33,18 +34,20 @@ export class AddRuleCommand extends BaseCommand {
         mkdirSync(rulesDir, { recursive: true });
         const filePath = join(rulesDir, `${ruleName}.md`);
         if (existsSync(filePath)) {
-            tag('warning').log(`Rule file already exists: ${filePath}`);
+            tag('warning').log(`Rule file already exists: ${relativeToCwd(filePath)}`);
             return null;
         }
         const content = opts?.content || `Instructions for ${agentName} agent.`;
         writeFileSync(filePath, `${content.trim()}\n`);
-        tag('success').log(`Rule created: ${filePath}`);
-        if (opts?.urlPattern) {
-            tag('info').log(`Add to config: ai.agents.${agentName}.rules: [{ '${opts.urlPattern}': '${ruleName}' }]`);
-        }
-        else {
-            tag('info').log(`Add to config: ai.agents.${agentName}.rules: ['${ruleName}']`);
-        }
+        const configLine = opts?.urlPattern ? `ai.agents.${agentName}.rules: [{ '${opts.urlPattern}': '${ruleName}' }]` : `ai.agents.${agentName}.rules: ['${ruleName}']`;
+        const sections = [
+            {
+                label: 'Rule',
+                path: filePath,
+                commands: [{ label: 'Add to config', command: configLine }],
+            },
+        ];
+        printNextSteps(sections);
         return filePath;
     }
 }

package/dist/src/commands/base-command.js

@@ -1,4 +1,8 @@
+import chalk from 'chalk';
 import { Command } from 'commander';
+import { isInteractive } from '../ai/task-agent.js';
+import { getCliName } from '../utils/cli-name.js';
+import { tag } from '../utils/logger.js';
 export class BaseCommand {
     aliases = [];
     options = [];
@@ -11,6 +15,22 @@ export class BaseCommand {
     matches(commandName) {
         return this.name === commandName || this.aliases.includes(commandName);
     }
+    printSuggestions() {
+        if (this.suggestions.length === 0)
+            return;
+        const prefix = isInteractive() ? '/' : `${getCliName()} `;
+        tag('info').log('');
+        tag('info').log(chalk.bold('Suggested:'));
+        for (const { command, hint } of this.suggestions) {
+            tag('info').log('');
+            if (!command) {
+                tag('info').log(chalk.dim(hint));
+                continue;
+            }
+            tag('info').log(chalk.dim(`${hint}:`));
+            tag('info').log(`  ${chalk.yellow(`${prefix}${command}`)}`);
+        }
+    }
     parseArgs(args) {
         const cmd = new Command();
         cmd.exitOverride();

package/dist/src/commands/clean-command.js

@@ -7,6 +7,7 @@ export const CLEAN_TARGETS = {
     states: { description: 'page states', getDir: () => outputPath('states') },
     research: { description: 'research cache', getDir: () => outputPath('research') },
     plans: { description: 'test plans', getDir: () => outputPath('plans') },
+    tests: { description: 'generated tests', getDir: () => outputPath('tests') },
     experiences: { description: 'experience files', getDir: () => getExperienceDir() },
     output: { description: 'all output files', getDir: () => outputPath() },
 };
@@ -38,8 +39,8 @@ function cleanDirectoryContents(dirPath) {
 }
 export class CleanCommand extends BaseCommand {
     name = 'clean';
-    description = 'Clean files: clean [states|research|plans|experiences|output]';
-    suggestions = Object.keys(CLEAN_TARGETS).map((t) => `/clean ${t}`);
+    description = 'Clean files: clean [states|research|plans|tests|experiences|output]';
+    suggestions = Object.entries(CLEAN_TARGETS).map(([name, target]) => ({ command: `clean ${name}`, hint: `clean ${target.description}` }));
     async execute(args) {
         const target = args.trim().toLowerCase();
         if (!target) {

package/dist/src/commands/compact-command.js

@@ -0,0 +1,138 @@
+import { basename } from 'node:path';
+import chalk from 'chalk';
+import { tag } from '../utils/logger.js';
+import { BaseCommand } from './base-command.js';
+const COMPACT_THRESHOLD = 5000;
+export class CompactCommand extends BaseCommand {
+    name = 'compact';
+    description = 'Compact stored experience files; optionally filtered by filename or URL substring';
+    options = [
+        { flags: '--dry-run', description: 'Preview without running AI or writing files' },
+        { flags: '--no-merge', description: 'Skip the cross-URL merge step when compacting all' },
+    ];
+    suggestions = [];
+    async execute(args) {
+        const { opts, args: remaining } = this.parseArgs(args);
+        const target = remaining[0];
+        const dryRun = !!opts.dryRun;
+        const merge = opts.merge !== false;
+        const tracker = this.explorBot.getExperienceTracker();
+        const files = this.resolveTarget(tracker, target);
+        if (files === null) {
+            tag('info').log('No experience files found.');
+            return;
+        }
+        if (files.length === 0) {
+            tag('info').log(`No experience files match target "${target}"`);
+            return;
+        }
+        const compactor = this.explorBot.agentExperienceCompactor();
+        if (dryRun) {
+            this.printDryRun(compactor, files, target, !target && merge);
+            this.suggestions = this.buildDryRunSuggestions(compactor, files, target);
+            return;
+        }
+        if (!target) {
+            const { merged, compacted } = await this.runFullSweep(compactor, merge);
+            tag('success').log(`Done. ${merged} merged, ${compacted} compacted.`);
+            this.suggestions = [{ command: 'experience', hint: 'list stored experiences' }];
+            return;
+        }
+        tag('info').log(`Compacting ${files.length} experience file${files.length === 1 ? '' : 's'}…`);
+        const compacted = await compactor.compactFiles(files);
+        if (compacted === 0) {
+            tag('info').log('No experience changes — nothing to strip and all content under size limit.');
+        }
+        else {
+            tag('success').log(`Compacted ${compacted}/${files.length} experience file${files.length === 1 ? '' : 's'}.`);
+        }
+        this.suggestions = [{ command: `experience ${target}`, hint: 'view updated file' }];
+    }
+    buildDryRunSuggestions(compactor, files, target) {
+        const wouldTouch = files.filter((f) => {
+            const stripped = compactor.stripNonUsefulEntries(f.content);
+            return stripped !== f.content || stripped.length >= COMPACT_THRESHOLD || compactor.isRecent(f);
+        });
+        if (wouldTouch.length === 0)
+            return [];
+        const argsPart = target ? ` ${target}` : '';
+        const count = wouldTouch.length;
+        return [{ command: `compact${argsPart}`, hint: `run compaction for real (${count} file${count === 1 ? '' : 's'} will be touched)` }];
+    }
+    async runFullSweep(compactor, merge) {
+        if (!merge) {
+            tag('info').log('Compacting all experience files (merge skipped)…');
+            const compacted = await compactor.compactFiles(this.explorBot.getExperienceTracker().getAllExperience());
+            return { merged: 0, compacted };
+        }
+        tag('info').log('Merging experience files with similar URLs, then compacting all…');
+        return compactor.compactAllExperiences();
+    }
+    resolveTarget(tracker, target) {
+        const all = tracker.getAllExperience();
+        if (all.length === 0)
+            return null;
+        if (!target)
+            return all;
+        if (target.endsWith('.md')) {
+            const bare = target.slice(0, -3);
+            const byFilename = all.find((f) => basename(f.filePath, '.md') === bare);
+            return byFilename ? [byFilename] : [];
+        }
+        const filter = target.toLowerCase();
+        return all.filter((f) => (f.data.url || '').toLowerCase().includes(filter));
+    }
+    printDryRun(compactor, files, target, willMerge) {
+        const lines = [];
+        const title = target ? `Dry run — target: "${target}"` : 'Dry run — full sweep';
+        lines.push(chalk.bold.underline.cyan(title));
+        if (willMerge) {
+            lines.push(chalk.dim('Merge step would run across all files before compaction.'));
+        }
+        let wouldStrip = 0;
+        let wouldAiReview = 0;
+        let wouldAiCompact = 0;
+        let totalChars = 0;
+        for (const file of files) {
+            const chars = file.content.length;
+            totalChars += chars;
+            const stripped = compactor.stripNonUsefulEntries(file.content);
+            const strippedChars = stripped.length;
+            const charsRemoved = chars - strippedChars;
+            const willStrip = stripped !== file.content;
+            const willReview = compactor.isRecent(file);
+            const willAi = strippedChars >= COMPACT_THRESHOLD;
+            if (willStrip)
+                wouldStrip++;
+            if (willReview)
+                wouldAiReview++;
+            if (willAi)
+                wouldAiCompact++;
+            const name = basename(file.filePath);
+            const url = file.data.url || chalk.dim('(no url)');
+            const markers = [];
+            if (willStrip) {
+                const label = charsRemoved > 0 ? `✂ strip -${charsRemoved} chars` : '✂ strip (rewrite)';
+                markers.push(chalk.yellow(label));
+            }
+            if (willReview)
+                markers.push(chalk.magenta('✓ ai-review'));
+            if (willAi)
+                markers.push(chalk.yellow('✎ ai-compact'));
+            if (markers.length === 0)
+                markers.push(chalk.dim('· skip'));
+            lines.push('');
+            lines.push(chalk.bold.green(name));
+            lines.push(`    ${chalk.cyan(url)}`);
+            lines.push(`    ${chalk.dim('size:')} ${chars} chars  ${markers.join('  ')}`);
+        }
+        lines.push('');
+        lines.push(chalk.bold('Summary'));
+        lines.push(`  ${chalk.dim('Files matched:')}      ${chalk.bold(String(files.length))}`);
+        lines.push(`  ${chalk.dim('Would strip:')}        ${chalk.bold(String(wouldStrip))} ${chalk.dim('(remove legacy / FAILED / Visual click, rename to FLOW/ACTION)')}`);
+        lines.push(`  ${chalk.dim('Would ai-review:')}    ${chalk.bold(String(wouldAiReview))} ${chalk.dim('(recent files ≤30d — quality/reusability check)')}`);
+        lines.push(`  ${chalk.dim('Would ai-compact:')}   ${chalk.bold(String(wouldAiCompact))} ${chalk.dim(`(over ${COMPACT_THRESHOLD} chars after strip)`)}`);
+        lines.push(`  ${chalk.dim('Total chars:')}        ${chalk.bold(String(totalChars))}`);
+        tag('info').log(lines.join('\n'));
+    }
+}

package/dist/src/commands/context-command.js

@@ -7,7 +7,13 @@ import { BaseCommand } from './base-command.js';
 export class ContextCommand extends BaseCommand {
     name = 'context';
     description = 'Show page context summary (URL, headings, experience, knowledge, ARIA, HTML, research)';
-    suggestions = ['context:aria', 'context:html', 'context:knowledge', 'context:experience', 'context:data'];
+    suggestions = [
+        { command: 'context:aria', hint: 'show page ARIA snapshot' },
+        { command: 'context:html', hint: 'show page HTML' },
+        { command: 'context:knowledge', hint: 'show relevant knowledge' },
+        { command: 'context:experience', hint: 'show relevant experience' },
+        { command: 'context:data', hint: 'show captured page data' },
+    ];
     options = [
         { flags: '--visual', description: 'Include annotated screenshot' },
         { flags: '--screenshot', description: 'Include annotated screenshot' },

package/dist/src/commands/drill-command.js

@@ -2,7 +2,10 @@ import { BaseCommand } from './base-command.js';
 export class DrillCommand extends BaseCommand {
     name = 'drill';
     description = 'Drill all components on current page to learn interactions';
-    suggestions = ['/research - to see UI map first', '/navigate <page> - to go to another page'];
+    suggestions = [
+        { command: 'research', hint: 'see UI map first' },
+        { command: 'navigate <page>', hint: 'go to another page' },
+    ];
     async execute(args) {
         const knowledgePath = this.parseKnowledgeArg(args);
         const maxComponents = this.parseMaxArg(args);

package/dist/src/commands/experience-command.js

@@ -0,0 +1,104 @@
+import chalk from 'chalk';
+import { tag } from '../utils/logger.js';
+import { BaseCommand } from './base-command.js';
+export class ExperienceCommand extends BaseCommand {
+    name = 'experience';
+    description = 'List stored experiences; filter by filename or URL substring; expand a section by ref (e.g. LW1)';
+    options = [
+        { flags: '--recent', description: 'Only files modified within the last 30 days' },
+        { flags: '--old', description: 'Only files modified more than 30 days ago' },
+    ];
+    suggestions = [];
+    async execute(args) {
+        const { opts, args: remaining } = this.parseArgs(args);
+        if (opts.recent && opts.old) {
+            tag('info').log('Flags --recent and --old are mutually exclusive.');
+            return;
+        }
+        const recency = opts.recent ? 'recent' : opts.old ? 'old' : undefined;
+        const tracker = this.explorBot.getExperienceTracker();
+        const [first, second] = remaining;
+        const combinedRef = first?.match(/^([A-Z]+)[.\-]?(\d+)$/i);
+        if (combinedRef) {
+            this.expand(tracker, combinedRef[1].toUpperCase(), Number(combinedRef[2]));
+            return;
+        }
+        if (first && /^[A-Z]+$/i.test(first) && second && /^\d+$/.test(second)) {
+            this.expand(tracker, first.toUpperCase(), Number(second));
+            return;
+        }
+        const secondRef = second?.match(/^([A-Z]+)[.\-]?(\d+)$/i);
+        if (first && secondRef) {
+            this.expand(tracker, secondRef[1].toUpperCase(), Number(secondRef[2]), first);
+            return;
+        }
+        if (first && second && /^\d+$/.test(second)) {
+            const toc = tracker.listAllExperienceToc(first, { recency });
+            if (toc.length === 0) {
+                tag('info').log(`No experience found matching: ${first}`);
+                return;
+            }
+            this.expand(tracker, toc[0].fileTag, Number(second), first);
+            return;
+        }
+        const toc = tracker.listAllExperienceToc(first, { recency });
+        if (toc.length === 0) {
+            const scope = recency === 'recent' ? ' (recent only)' : recency === 'old' ? ' (old only)' : '';
+            tag('info').log(first ? `No experience found matching: ${first}${scope}` : `No experience files found${scope}. Experience is recorded automatically during test sessions.`);
+            return;
+        }
+        tag('info').log(this.formatToc(toc, first, recency));
+        const hints = [];
+        const exampleRef = `${toc[0].fileTag}1`;
+        hints.push({ command: `experience ${exampleRef}`, hint: 'read a section' });
+        const overloaded = toc.filter((entry) => entry.sections.length >= 10);
+        for (const entry of overloaded) {
+            hints.push({ command: `compact ${entry.fileHash}.md`, hint: `compact this file (${entry.sections.length} sections)` });
+        }
+        this.suggestions = hints;
+    }
+    expand(tracker, fileTag, sectionIndex, urlFilter) {
+        const section = tracker.getExperienceSectionByTag(fileTag, sectionIndex, urlFilter);
+        if (!section) {
+            tag('info').log(`No section ${fileTag}${sectionIndex} found${urlFilter ? ` for URL matching: ${urlFilter}` : ''}`);
+            return;
+        }
+        tag('info').log(`${chalk.dim('File:')} ${chalk.bold.green(`${section.fileHash}.md`)}`);
+        tag('info').log(`${chalk.dim('URL:')}  ${chalk.bold.cyan(section.url)}`);
+        tag('info').log(`${chalk.green(`${fileTag}${sectionIndex}`)} ${chalk.bold(section.title)}`);
+        tag('multiline').log(this.stripLeadingHeading(section.content.trim()));
+    }
+    formatToc(toc, urlFilter, recency) {
+        const totalSections = toc.reduce((sum, entry) => sum + entry.sections.length, 0);
+        const lines = [];
+        const scope = recency === 'recent' ? ' (recent, ≤30d)' : recency === 'old' ? ' (old, >30d)' : '';
+        const title = urlFilter ? `Experience matching "${urlFilter}"${scope}` : `Stored experience${scope}`;
+        lines.push(chalk.bold.underline.cyan(title));
+        for (const entry of toc) {
+            lines.push('');
+            lines.push(chalk.bold.green(`${entry.fileHash}.md`));
+            lines.push(`    ${chalk.cyan(entry.url)}`);
+            for (let i = 0; i < entry.sections.length; i++) {
+                const section = entry.sections[i];
+                const isLast = i === entry.sections.length - 1;
+                const branch = isLast ? '└─' : '├─';
+                const ref = chalk.yellow(`${entry.fileTag}${section.index}`);
+                lines.push(`    ${chalk.dim(branch)} ${ref} ${chalk.dim(':')} ${section.title}`);
+            }
+        }
+        const urls = new Set(toc.map((e) => e.url)).size;
+        lines.push('');
+        lines.push(chalk.bold('Summary'));
+        lines.push(`  ${chalk.dim('URLs:')}     ${chalk.bold(String(urls))}`);
+        lines.push(`  ${chalk.dim('Files:')}    ${chalk.bold(String(toc.length))}`);
+        lines.push(`  ${chalk.dim('Entries:')}  ${chalk.bold(String(totalSections))}`);
+        return lines.join('\n');
+    }
+    stripLeadingHeading(body) {
+        const lines = body.split('\n');
+        if (lines[0]?.match(/^#{1,6}\s/)) {
+            return lines.slice(1).join('\n').trimStart();
+        }
+        return body;
+    }
+}

package/dist/src/commands/explore-command.js

@@ -1,9 +1,11 @@
 import figureSet from 'figures';
-import path from 'node:path';
 import { getStyles } from '../ai/planner/styles.js';
+import { Stats } from '../stats.js';
 import { getCliName } from "../utils/cli-name.js";
-import { jsonToTable } from '../utils/markdown-parser.js';
+import { ErrorPageError } from "../utils/error-page.js";
 import { tag } from '../utils/logger.js';
+import { jsonToTable } from '../utils/markdown-parser.js';
+import { printNextSteps, relativeToCwd } from "../utils/next-steps.js";
 import { BaseCommand } from './base-command.js';
 export class ExploreCommand extends BaseCommand {
     name = 'explore';
@@ -12,7 +14,11 @@ export class ExploreCommand extends BaseCommand {
         { flags: '--max-tests <number>', description: 'Maximum number of tests to run' },
         { flags: '--focus <feature>', description: 'Focus area for exploration' },
     ];
-    suggestions = ['/navigate <page> - to go to another page', '/research - to analyze', '/plan <feature> - to plan testing'];
+    suggestions = [
+        { command: 'navigate <page>', hint: 'go to another page' },
+        { command: 'research', hint: 'analyze current page' },
+        { command: 'plan <feature>', hint: 'plan testing' },
+    ];
     maxTests;
     testsRun = 0;
     completedPlans = [];
@@ -22,13 +28,15 @@ export class ExploreCommand extends BaseCommand {
             this.maxTests = Number.parseInt(opts.maxTests, 10);
         }
         const feature = opts.focus || remaining.join(' ') || undefined;
+        Stats.mode ??= 'explore';
+        Stats.focus ??= feature;
         const mainUrl = this.explorBot.getExplorer().getStateManager().getCurrentState()?.url;
         await this.runAllStyles(mainUrl, feature);
         const mainPlan = this.explorBot.getCurrentPlan();
         if (!mainPlan)
             return;
         this.completedPlans.push(mainPlan);
-        if (!this.isLimitReached()) {
+        if (!feature && !this.isLimitReached()) {
             const planner = this.explorBot.agentPlanner();
             while (true) {
                 if (this.isLimitReached())
@@ -57,8 +65,8 @@ export class ExploreCommand extends BaseCommand {
         if (mainUrl)
             await this.explorBot.visit(mainUrl);
         const savedPath = this.explorBot.savePlans(this.completedPlans);
-        this.printResults(savedPath);
-        this.printRerunSuggestions();
+        this.printResults();
+        this.printNextSteps(savedPath);
     }
     async runAllStyles(pageUrl, feature, parentPlan, completedPlans) {
         let fresh = true;
@@ -69,12 +77,27 @@ export class ExploreCommand extends BaseCommand {
             const opts = { fresh, style, completedPlans };
             if (fresh && parentPlan)
                 opts.extend = parentPlan;
-            await this.explorBot.plan(feature, opts);
+            await this.planWithRetry(feature, opts, pageUrl);
             await this.runPendingTests();
             fresh = false;
         }
     }
-    printResults(savedPath) {
+    async planWithRetry(feature, opts, pageUrl) {
+        await this.explorBot.plan(feature, opts);
+        if (!this.explorBot.lastPlanError)
+            return;
+        if (this.explorBot.lastPlanError instanceof ErrorPageError) {
+            throw this.explorBot.lastPlanError;
+        }
+        tag('info').log(`Retrying planning style '${opts.style}'...`);
+        if (pageUrl)
+            await this.explorBot.visit(pageUrl);
+        await this.explorBot.plan(feature, opts);
+        if (this.explorBot.lastPlanError) {
+            tag('warning').log(`Planning style '${opts.style}' failed after retry, skipping`);
+        }
+    }
+    printResults() {
         const allTests = this.completedPlans.flatMap((plan) => plan.tests.filter((t) => t.startTime != null).map((test) => ({ test, planTitle: plan.title })));
         if (allTests.length === 0)
             return;
@@ -105,20 +128,32 @@ export class ExploreCommand extends BaseCommand {
             columns.push('Plan');
         tag('multiline').log(jsonToTable(rows, columns));
         tag('info').log(`${figureSet.tick} ${allTests.length} tests completed`);
-        if (savedPath) {
-            const relativePath = path.relative(process.cwd(), savedPath);
-            tag('info').log(`Re-run tests: ${getCliName()} test ${relativePath} <index>`);
-        }
     }
-    printRerunSuggestions() {
+    printNextSteps(savedPlanPath) {
+        const cli = getCliName();
+        const sections = [];
+        if (savedPlanPath) {
+            const relPlan = relativeToCwd(savedPlanPath);
+            sections.push({
+                label: 'Plan',
+                path: savedPlanPath,
+                commands: [
+                    { label: 'Re-run', command: `${cli} test ${relPlan} 1` },
+                    { label: 'Run all', command: `${cli} test ${relPlan} *` },
+                    { label: 'Run range', command: `${cli} test ${relPlan} 1-3` },
+                ],
+            });
+        }
         const savedFiles = this.explorBot.agentHistorian().getSavedFiles();
-        if (savedFiles.length === 0)
-            return;
-        for (const filePath of savedFiles) {
-            tag('info').log(`Generated: ${path.basename(filePath)}`);
+        if (savedFiles.length > 0) {
+            const commands = savedFiles.map((f) => ({ label: '', command: `${cli} rerun ${relativeToCwd(f)}` }));
+            commands.push({ label: 'List tests', command: `${cli} runs` });
+            sections.push({
+                label: `Generated tests (${savedFiles.length})`,
+                commands,
+            });
         }
-        tag('info').log(`List tests: ${getCliName()} runs`);
-        tag('info').log(`Re-run with healing: ${getCliName()} rerun <filename> [index]`);
+        printNextSteps(sections);
     }
     isLimitReached() {
         return this.maxTests != null && this.testsRun >= this.maxTests;

package/dist/src/commands/freesail-command.js

@@ -1,5 +1,6 @@
 import { Planner } from '../ai/planner.js';
 import { Researcher } from '../ai/researcher.js';
+import { Stats } from '../stats.js';
 import { tag } from '../utils/logger.js';
 import { loop } from '../utils/loop.js';
 import { BaseCommand } from './base-command.js';
@@ -16,6 +17,7 @@ export class FreesailCommand extends BaseCommand {
         { flags: '--max-tests <number>', description: 'Maximum number of tests to run' },
     ];
     async execute(args) {
+        Stats.mode = 'freesail';
         const { opts } = this.parseArgs(args);
         let strategy;
         if (opts.deep)

package/dist/src/commands/index.js

@@ -1,19 +1,21 @@
+import { AddRuleCommand } from './add-rule-command.js';
 import { CleanCommand } from './clean-command.js';
-import { DebugCommand } from './debug-command.js';
+import { CompactCommand } from './compact-command.js';
 import { ContextAriaCommand } from './context-aria-command.js';
 import { ContextCommand } from './context-command.js';
 import { ContextDataCommand } from './context-data-command.js';
 import { ContextExperienceCommand } from './context-experience-command.js';
 import { ContextHtmlCommand } from './context-html-command.js';
 import { ContextKnowledgeCommand } from './context-knowledge-command.js';
+import { DebugCommand } from './debug-command.js';
 import { DrillCommand } from './drill-command.js';
 import { ExitCommand } from './exit-command.js';
+import { ExperienceCommand } from './experience-command.js';
 import { ExploreCommand } from './explore-command.js';
 import { FreesailCommand } from './freesail-command.js';
 import { HelpCommand } from './help-command.js';
-import { AddRuleCommand } from './add-rule-command.js';
-import { LearnCommand } from './learn-command.js';
 import { KnowsCommand } from './knows-command.js';
+import { LearnCommand } from './learn-command.js';
 import { NavigateCommand } from './navigate-command.js';
 import { PathCommand } from './path-command.js';
 import { PlanClearCommand } from './plan-clear-command.js';
@@ -47,6 +49,8 @@ const commandClasses = [
     PathCommand,
     LearnCommand,
     KnowsCommand,
+    ExperienceCommand,
+    CompactCommand,
     AddRuleCommand,
     ContextCommand,
     ContextAriaCommand,

package/dist/src/commands/init-command.js

@@ -1,9 +1,10 @@
 import { existsSync, mkdirSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, extname, join, resolve } from 'node:path';
-import { log, tag } from '../utils/logger.js';
-import dedent from 'dedent';
 import chalk from 'chalk';
+import dedent from 'dedent';
 import { getCliName } from "../utils/cli-name.js";
+import { log, tag } from '../utils/logger.js';
+import { relativeToCwd } from "../utils/next-steps.js";
 const DEFAULT_CONFIG_TEMPLATE = `import { createOpenRouter } from '@openrouter/ai-sdk-provider';
 // import { '<your provider here>' } from '<your provider package here>';
 
@@ -57,10 +58,10 @@ export function runInitCommand(options) {
         const dir = resolve(customPath);
         if (!existsSync(dir)) {
             mkdirSync(dir, { recursive: true });
-            log(`Created directory: ${dir}`);
+            log(`Created directory: ${relativeToCwd(dir)}`);
         }
         process.chdir(dir);
-        log(`Working in directory: ${dir}`);
+        log(`Working in directory: ${relativeToCwd(dir)}`);
     }
     try {
         let outPath = resolve(configPath);
@@ -73,22 +74,22 @@ export function runInitCommand(options) {
         const dir = dirname(outPath);
         if (!existsSync(dir)) {
             mkdirSync(dir, { recursive: true });
-            log(`Created directory: ${dir}`);
+            log(`Created directory: ${relativeToCwd(dir)}`);
         }
         if (existsSync(outPath) && !force) {
-            log(`Config file already exists: ${outPath}`);
+            log(`Config file already exists: ${relativeToCwd(outPath)}`);
             log('Use --force to overwrite existing file');
             process.exit(1);
         }
         writeFileSync(outPath, DEFAULT_CONFIG_TEMPLATE, 'utf8');
-        log(`Created config file: ${outPath}`);
+        log(`Created config file: ${relativeToCwd(outPath)}`);
         const envPath = resolve(process.cwd(), '.env');
         if (!existsSync(envPath)) {
             writeFileSync(envPath, `${DEFAULT_ENV_TEMPLATE}\n`, 'utf8');
-            log(`Created env file: ${envPath}`);
+            log(`Created env file: ${relativeToCwd(envPath)}`);
         }
         else {
-            log(`Env file already exists: ${envPath}`);
+            log(`Env file already exists: ${relativeToCwd(envPath)}`);
         }
         log('');
         log('Next steps:');
@@ -102,7 +103,7 @@ export function runInitCommand(options) {
         tag('substep').log(chalk.yellow(`${getCliName()} start /dashboard`));
         if (!existsSync('./output')) {
             mkdirSync('./output', { recursive: true });
-            log('Created directory: ./output');
+            log('Created directory: output');
         }
     }
     catch (error) {

package/dist/src/commands/learn-command.js

@@ -5,7 +5,7 @@ import { BaseCommand } from './base-command.js';
 export class LearnCommand extends BaseCommand {
     name = 'learn';
     description = 'Store knowledge for current page';
-    suggestions = ['/knows - to view all knowledge'];
+    suggestions = [{ command: 'knows', hint: 'view all knowledge' }];
     async execute(args) {
         const note = args.trim();
         if (!note) {

package/dist/src/commands/navigate-command.js

@@ -3,7 +3,10 @@ import { BaseCommand } from './base-command.js';
 export class NavigateCommand extends BaseCommand {
     name = 'navigate';
     description = 'Navigate to URI or state using AI';
-    suggestions = ['/research - to analyze current page', '/plan <feature> - to plan testing'];
+    suggestions = [
+        { command: 'research', hint: 'analyze current page' },
+        { command: 'plan <feature>', hint: 'plan testing' },
+    ];
     async execute(args) {
         const destination = args.trim();
         if (!destination) {

package/dist/src/commands/plan-clear-command.js

@@ -3,7 +3,10 @@ import { BaseCommand } from './base-command.js';
 export class PlanClearCommand extends BaseCommand {
     name = 'plan:clear';
     description = 'Clear current plan and create a new one';
-    suggestions = ['/test - to launch first test', '/test * - to launch all tests'];
+    suggestions = [
+        { command: 'test', hint: 'launch first test' },
+        { command: 'test *', hint: 'launch all tests' },
+    ];
     async execute(args) {
         this.explorBot.clearPlan();
         tag('success').log('Plan cleared');