explorbot 0.1.31 → 0.2.0

package/dist/src/command-handler.d.ts

@@ -0,0 +1,68 @@
+import { type BaseCommand } from './commands/index.js';
+import type { ExplorBot } from './explorbot.js';
+export type InputSubmitCallback = (input: string) => Promise<void>;
+export interface InputManager {
+    registerInputPane(addLog: (entry: string) => void, onSubmit: InputSubmitCallback): () => void;
+    getAvailableCommands(): string[];
+    getFilteredCommands(input: string): string[];
+    getAutocomplete(input: string, cursor: number): CommandAutocomplete;
+    setExitOnEmptyInput(enabled: boolean): void;
+}
+export interface ParsedCommand {
+    name: string;
+    args: string[];
+}
+export interface CommandAutocompleteSuggestion {
+    value: string;
+    display: string;
+    description: string;
+    argumentHint?: string;
+}
+export interface CommandAutocomplete {
+    suggestions: CommandAutocompleteSuggestion[];
+    replaceFrom: number;
+    replaceTo: number;
+    visible: boolean;
+    argumentHint?: string;
+}
+export declare class CommandHandler implements InputManager {
+    explorBot: ExplorBot;
+    commands: BaseCommand[];
+    registeredInputPanes: Set<{
+        addLog: (entry: string) => void;
+        onSubmit: InputSubmitCallback;
+    }>;
+    exitOnEmptyInput: boolean;
+    runningCommands: Set<string>;
+    constructor(explorBot: ExplorBot);
+    findCommand(name: string): BaseCommand | undefined;
+    getAvailableCommands(): string[];
+    getAutocomplete(input: string, cursor: number): CommandAutocomplete;
+    getCommandDescriptions(): {
+        name: string;
+        description: string;
+        options: string;
+    }[];
+    executeCommand(input: string): Promise<void>;
+    executeBrowserCommand(input: string): Promise<void>;
+    isCommand(input: string): boolean;
+    registerInputPane(addLog: (entry: string) => void, onSubmit: InputSubmitCallback): () => void;
+    getFilteredCommands(input: string): string[];
+    setExitOnEmptyInput(enabled: boolean): void;
+    submitInput(input: string): Promise<void>;
+    getSlashAutocomplete(input: string, cursor: number): CommandAutocomplete | null;
+    getCodeceptAutocomplete(input: string, cursor: number): CommandAutocomplete | null;
+    getExitAutocomplete(input: string, cursor: number): CommandAutocomplete | null;
+    getSlashCommandEntries(): AutocompleteEntry[];
+    getCodeceptEntries(): AutocompleteEntry[];
+    rankSuggestions(query: string, entries: AutocompleteEntry[]): CommandAutocompleteSuggestion[];
+    getMatchScore(query: string, candidate: string): number;
+}
+type AutocompleteEntry = {
+    aliases: string[];
+    argumentHint?: string;
+    canonical: string;
+    description: string;
+    value: string;
+};
+export {};

package/dist/src/commands/add-rule-command.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand, type Suggestion } from './base-command.js';
+export declare class AddRuleCommand extends BaseCommand {
+    name: string;
+    description: string;
+    suggestions: Suggestion[];
+    execute(args: string): Promise<void>;
+    static createRuleFile(agentName: string, ruleName: string, opts?: {
+        content?: string;
+        urlPattern?: string;
+    }): string | null;
+}

package/dist/src/commands/base-command.d.ts

@@ -0,0 +1,26 @@
+import type { ExplorBot } from '../explorbot.js';
+export interface CommandOption {
+    flags: string;
+    description: string;
+}
+export interface Suggestion {
+    command?: string;
+    hint: string;
+}
+export declare abstract class BaseCommand {
+    abstract name: string;
+    abstract description: string;
+    aliases: string[];
+    options: CommandOption[];
+    tuiEnabled: boolean;
+    suggestions: Suggestion[];
+    explorBot: ExplorBot;
+    constructor(explorBot: ExplorBot);
+    abstract execute(args: string): Promise<void>;
+    matches(commandName: string): boolean;
+    printSuggestions(): void;
+    parseArgs(args: string): {
+        opts: Record<string, string | boolean>;
+        args: string[];
+    };
+}

package/dist/src/commands/clean-command.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand, type Suggestion } from './base-command.js';
+export declare const CLEAN_TARGETS: Record<string, {
+    description: string;
+    getDir: () => string;
+}>;
+export declare class CleanCommand extends BaseCommand {
+    name: string;
+    description: string;
+    suggestions: Suggestion[];
+    execute(args: string): Promise<void>;
+    cleanTarget(name: string): void;
+}

package/dist/src/commands/compact-command.d.ts

@@ -0,0 +1,20 @@
+import type { ExperienceFile } from '../experience-tracker.js';
+import type { ExperienceTracker } from '../experience-tracker.js';
+import { BaseCommand, type Suggestion } from './base-command.js';
+export declare class CompactCommand extends BaseCommand {
+    name: string;
+    description: string;
+    options: {
+        flags: string;
+        description: string;
+    }[];
+    suggestions: Suggestion[];
+    execute(args: string): Promise<void>;
+    buildDryRunSuggestions(compactor: ReturnType<typeof this.explorBot.agentExperienceCompactor>, files: ExperienceFile[], target?: string): Suggestion[];
+    runFullSweep(compactor: ReturnType<typeof this.explorBot.agentExperienceCompactor>, merge: boolean): Promise<{
+        merged: number;
+        compacted: number;
+    }>;
+    resolveTarget(tracker: ExperienceTracker, target?: string): ExperienceFile[] | null;
+    printDryRun(compactor: ReturnType<typeof this.explorBot.agentExperienceCompactor>, files: ExperienceFile[], target: string | undefined, willMerge: boolean): void;
+}

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

@@ -1,8 +1,8 @@
 import { basename } from 'node:path';
 import chalk from 'chalk';
+import { COMPACT_MAX_LENGTH } from '../ai/experience-compactor.js';
 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';
@@ -16,7 +16,7 @@ export class CompactCommand extends BaseCommand {
         const target = remaining[0];
         const dryRun = !!opts.dryRun;
         const merge = opts.merge !== false;
-        const tracker = this.explorBot.getExperienceTracker();
+        const tracker = this.explorBot.experienceTracker();
         const files = this.resolveTarget(tracker, target);
         if (files === null) {
             tag('info').log('No experience files found.');
@@ -51,7 +51,7 @@ export class CompactCommand extends BaseCommand {
     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);
+            return stripped !== f.content || stripped.length >= COMPACT_MAX_LENGTH || compactor.isRecent(f);
         });
         if (wouldTouch.length === 0)
             return [];
@@ -62,7 +62,7 @@ export class CompactCommand extends BaseCommand {
     async runFullSweep(compactor, merge) {
         if (!merge) {
             tag('info').log('Compacting all experience files (merge skipped)…');
-            const compacted = await compactor.compactFiles(this.explorBot.getExperienceTracker().getAllExperience());
+            const compacted = await compactor.compactFiles(this.explorBot.experienceTracker().getAllExperience());
             return { merged: 0, compacted };
         }
         tag('info').log('Merging experience files with similar URLs, then compacting all…');
@@ -101,7 +101,7 @@ export class CompactCommand extends BaseCommand {
             const charsRemoved = chars - strippedChars;
             const willStrip = stripped !== file.content;
             const willReview = compactor.isRecent(file);
-            const willAi = strippedChars >= COMPACT_THRESHOLD;
+            const willAi = strippedChars >= COMPACT_MAX_LENGTH;
             if (willStrip)
                 wouldStrip++;
             if (willReview)
@@ -131,7 +131,7 @@ export class CompactCommand extends BaseCommand {
         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('Would ai-compact:')}   ${chalk.bold(String(wouldAiCompact))} ${chalk.dim(`(over ${COMPACT_MAX_LENGTH} chars after strip)`)}`);
         lines.push(`  ${chalk.dim('Total chars:')}        ${chalk.bold(String(totalChars))}`);
         tag('info').log(lines.join('\n'));
     }

package/dist/src/commands/context-aria-command.d.ts

@@ -0,0 +1,6 @@
+import { BaseCommand } from './base-command.js';
+export declare class ContextAriaCommand extends BaseCommand {
+    name: string;
+    description: string;
+    execute(_args: string): Promise<void>;
+}

package/dist/src/commands/context-command.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand, type Suggestion } from './base-command.js';
+export declare class ContextCommand extends BaseCommand {
+    name: string;
+    description: string;
+    suggestions: Suggestion[];
+    options: {
+        flags: string;
+        description: string;
+    }[];
+    execute(args: string): Promise<void>;
+}

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

@@ -36,7 +36,7 @@ export class ContextCommand extends BaseCommand {
         }
         const actionResult = await explorer.createAction().capturePageState({ includeScreenshot: isVisual });
         const experienceTracker = explorer.getStateManager().getExperienceTracker();
-        const knowledgeTracker = this.explorBot.getKnowledgeTracker();
+        const knowledgeTracker = this.explorBot.knowledgeTracker();
         let mode = 'compact';
         if (opts.full) {
             mode = 'full';

package/dist/src/commands/context-data-command.d.ts

@@ -0,0 +1,6 @@
+import { BaseCommand } from './base-command.js';
+export declare class ContextDataCommand extends BaseCommand {
+    name: string;
+    description: string;
+    execute(_args: string): Promise<void>;
+}

package/dist/src/commands/context-experience-command.d.ts

@@ -0,0 +1,6 @@
+import { BaseCommand } from './base-command.js';
+export declare class ContextExperienceCommand extends BaseCommand {
+    name: string;
+    description: string;
+    execute(_args: string): Promise<void>;
+}

package/dist/src/commands/context-html-command.d.ts

@@ -0,0 +1,6 @@
+import { BaseCommand } from './base-command.js';
+export declare class ContextHtmlCommand extends BaseCommand {
+    name: string;
+    description: string;
+    execute(_args: string): Promise<void>;
+}

package/dist/src/commands/context-knowledge-command.d.ts

@@ -0,0 +1,6 @@
+import { BaseCommand } from './base-command.js';
+export declare class ContextKnowledgeCommand extends BaseCommand {
+    name: string;
+    description: string;
+    execute(_args: string): Promise<void>;
+}

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

@@ -13,7 +13,7 @@ export class ContextKnowledgeCommand extends BaseCommand {
             throw new Error('No active page');
         }
         const actionResult = ActionResult.fromState(state);
-        const knowledgeTracker = this.explorBot.getKnowledgeTracker();
+        const knowledgeTracker = this.explorBot.knowledgeTracker();
         const knowledge = knowledgeTracker.getRelevantKnowledge(actionResult);
         if (knowledge.length === 0) {
             tag('info').log(`No knowledge found for: ${actionResult.url}`);

package/dist/src/commands/debug-command.d.ts

@@ -0,0 +1,6 @@
+import { BaseCommand } from './base-command.js';
+export declare class DebugCommand extends BaseCommand {
+    name: string;
+    description: string;
+    execute(_args: string): Promise<void>;
+}

package/dist/src/commands/drill-command.d.ts

@@ -0,0 +1,10 @@
+import { BaseCommand, type Suggestion } from './base-command.js';
+export declare class DrillCommand extends BaseCommand {
+    name: string;
+    description: string;
+    aliases: string[];
+    suggestions: Suggestion[];
+    execute(args: string): Promise<void>;
+    parseKnowledgeArg(args: string): string | undefined;
+    parseMaxArg(args: string): number | undefined;
+}

package/dist/src/commands/exit-command.d.ts

@@ -0,0 +1,7 @@
+import { BaseCommand } from './base-command.js';
+export declare class ExitCommand extends BaseCommand {
+    name: string;
+    description: string;
+    aliases: string[];
+    execute(_args: string): Promise<void>;
+}

package/dist/src/commands/experience-command.d.ts

@@ -0,0 +1,15 @@
+import type { ExperienceTocEntry, ExperienceTracker } from '../experience-tracker.js';
+import { BaseCommand, type Suggestion } from './base-command.js';
+export declare class ExperienceCommand extends BaseCommand {
+    name: string;
+    description: string;
+    options: {
+        flags: string;
+        description: string;
+    }[];
+    suggestions: Suggestion[];
+    execute(args: string): Promise<void>;
+    expand(tracker: ExperienceTracker, fileTag: string, sectionIndex: number, urlFilter?: string): void;
+    formatToc(toc: ExperienceTocEntry[], urlFilter?: string, recency?: 'recent' | 'old'): string;
+    stripLeadingHeading(body: string): string;
+}

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

@@ -16,7 +16,7 @@ export class ExperienceCommand extends BaseCommand {
             return;
         }
         const recency = opts.recent ? 'recent' : opts.old ? 'old' : undefined;
-        const tracker = this.explorBot.getExperienceTracker();
+        const tracker = this.explorBot.experienceTracker();
         const [first, second] = remaining;
         const combinedRef = first?.match(/^([A-Z]+)[.\-]?(\d+)$/i);
         if (combinedRef) {

package/dist/src/commands/explore-command.d.ts

@@ -0,0 +1,51 @@
+import { type Plan, type Test } from '../test-plan.js';
+import { BaseCommand, type Suggestion } from './base-command.js';
+export declare class ExploreCommand extends BaseCommand {
+    name: string;
+    description: string;
+    options: {
+        flags: string;
+        description: string;
+    }[];
+    suggestions: Suggestion[];
+    maxTests?: number;
+    dryRun: boolean;
+    testsRun: number;
+    completedPlans: Plan[];
+    failedSubPages: Set<string>;
+    oldTestRefs: Set<Test>;
+    priorityFilter?: Set<string>;
+    getCurrentPageUrl(): string | undefined;
+    execute(args: string): Promise<void>;
+    originLabel(test: Test): string;
+    printPreview(label: string, tests: Test[]): void;
+    runFreshMode(mainUrl: string | undefined, feature: string | undefined, styles?: string[]): Promise<void>;
+    runReuseMode(mainUrl: string | undefined, feature: string | undefined, cfg: ConfigureSpec): Promise<void>;
+    discoverNewSubPages(mainPlan: Plan, mainUrl: string | undefined, styles: string[] | undefined, knownUrls: Set<string>): Promise<void>;
+    replanAndRun(pageUrl: string | undefined, feature: string | undefined, existingPlan: Plan, styles?: string[]): Promise<void>;
+    runAllStyles(pageUrl?: string, feature?: string, parentPlan?: Plan, completedPlans?: Plan[], styles?: string[]): Promise<void>;
+    rememberCurrentPlan(): void;
+    planWithRetry(feature: string | undefined, opts: {
+        fresh: boolean;
+        style: string;
+        extend?: Plan;
+        completedPlans?: Plan[];
+        noSave?: boolean;
+    }, pageUrl?: string): Promise<void>;
+    parseConfigure(raw: string | undefined): ConfigureSpec;
+    printResults(): void;
+    printNextSteps(savedPlanPath?: string | null): void;
+    isLimitReached(): boolean;
+    runPendingTests(): Promise<void>;
+    runOneTest(test: Test): Promise<void>;
+}
+interface ConfigureSpec {
+    enabled: boolean;
+    newRatio: number;
+    fromPath?: string;
+    styles?: string[];
+    subpages?: 'none' | 'same' | 'new' | 'both';
+    pickBy?: 'priority' | 'random' | 'index';
+    priorities?: string[];
+}
+export {};

package/dist/src/commands/freesail-command.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from './base-command.js';
+export declare class FreesailCommand extends BaseCommand {
+    name: string;
+    description: string;
+    aliases: string[];
+    tuiEnabled: boolean;
+    options: {
+        flags: string;
+        description: string;
+    }[];
+    execute(args: string): Promise<void>;
+}

package/dist/src/commands/help-command.d.ts

@@ -0,0 +1,6 @@
+import { BaseCommand } from './base-command.js';
+export declare class HelpCommand extends BaseCommand {
+    name: string;
+    description: string;
+    execute(_args: string): Promise<void>;
+}

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

@@ -0,0 +1,4 @@
+import type { ExplorBot } from '../explorbot.js';
+import type { BaseCommand } from './base-command.js';
+export { BaseCommand } from './base-command.js';
+export declare function createCommands(explorBot: ExplorBot): BaseCommand[];

package/dist/src/commands/init-command.d.ts

@@ -0,0 +1,7 @@
+export declare function runInitCommand(options: InitCommandOptions): void;
+type InitCommandOptions = {
+    configPath?: string;
+    force?: boolean;
+    path?: string;
+};
+export {};

package/dist/src/commands/knows-command.d.ts

@@ -0,0 +1,10 @@
+import { BaseCommand } from './base-command.js';
+export declare function formatKnowledgeList(knowledge: Array<{
+    url: string;
+    firstLine: string;
+}>, limit?: number): string;
+export declare class KnowsCommand extends BaseCommand {
+    name: string;
+    description: string;
+    execute(args: string, limit?: number): Promise<void>;
+}

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

@@ -17,7 +17,7 @@ export class KnowsCommand extends BaseCommand {
     description = 'List all knowledge URLs or show matching knowledge for a URL';
     async execute(args, limit = 0) {
         const url = args.trim();
-        const tracker = this.explorBot.getKnowledgeTracker();
+        const tracker = this.explorBot.knowledgeTracker();
         if (!url) {
             const allKnowledge = tracker.listAllKnowledge();
             if (allKnowledge.length === 0) {

package/dist/src/commands/learn-command.d.ts

@@ -0,0 +1,7 @@
+import { BaseCommand, type Suggestion } from './base-command.js';
+export declare class LearnCommand extends BaseCommand {
+    name: string;
+    description: string;
+    suggestions: Suggestion[];
+    execute(args: string): Promise<void>;
+}

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

@@ -10,10 +10,12 @@ export class LearnCommand extends BaseCommand {
         const note = args.trim();
         if (!note) {
             const AddKnowledge = (await import('../components/AddKnowledge.js')).default;
-            const state = this.explorBot.getExplorer().getStateManager().getCurrentState();
+            const explorer = this.explorBot.getExplorer();
+            const state = explorer.getStateManager().getCurrentState();
             const initialUrl = state?.url || '';
             const { unmount } = render(React.createElement(AddKnowledge, {
                 initialUrl,
+                knowledgeTracker: explorer.getKnowledgeTracker(),
                 onComplete: () => unmount(),
                 onCancel: () => unmount(),
             }), {

package/dist/src/commands/navigate-command.d.ts

@@ -0,0 +1,7 @@
+import { BaseCommand, type Suggestion } from './base-command.js';
+export declare class NavigateCommand extends BaseCommand {
+    name: string;
+    description: string;
+    suggestions: Suggestion[];
+    execute(args: string): Promise<void>;
+}

package/dist/src/commands/path-command.d.ts

@@ -0,0 +1,10 @@
+import { BaseCommand } from './base-command.js';
+export declare class PathCommand extends BaseCommand {
+    name: string;
+    description: string;
+    options: {
+        flags: string;
+        description: string;
+    }[];
+    execute(args: string): Promise<void>;
+}

package/dist/src/commands/plan-clear-command.d.ts

@@ -0,0 +1,7 @@
+import { BaseCommand, type Suggestion } from './base-command.js';
+export declare class PlanClearCommand extends BaseCommand {
+    name: string;
+    description: string;
+    suggestions: Suggestion[];
+    execute(args: string): Promise<void>;
+}

package/dist/src/commands/plan-command.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand, type Suggestion } from './base-command.js';
+export declare class PlanCommand extends BaseCommand {
+    name: string;
+    description: string;
+    suggestions: Suggestion[];
+    options: {
+        flags: string;
+        description: string;
+    }[];
+    execute(args: string): Promise<void>;
+    printNextSteps(): void;
+    printPlanSummary(): void;
+    updateSuggestions(): void;
+}

package/dist/src/commands/plan-edit-command.d.ts

@@ -0,0 +1,7 @@
+import { BaseCommand, type Suggestion } from './base-command.js';
+export declare class PlanEditCommand extends BaseCommand {
+    name: string;
+    description: string;
+    suggestions: Suggestion[];
+    execute(_args: string): Promise<void>;
+}

package/dist/src/commands/plan-load-command.d.ts

@@ -0,0 +1,7 @@
+import { BaseCommand, type Suggestion } from './base-command.js';
+export declare class PlanLoadCommand extends BaseCommand {
+    name: string;
+    description: string;
+    suggestions: Suggestion[];
+    execute(args: string): Promise<void>;
+}

package/dist/src/commands/plan-reload-command.d.ts

@@ -0,0 +1,7 @@
+import { BaseCommand, type Suggestion } from './base-command.js';
+export declare class PlanReloadCommand extends BaseCommand {
+    name: string;
+    description: string;
+    suggestions: Suggestion[];
+    execute(args: string): Promise<void>;
+}

package/dist/src/commands/plan-save-command.d.ts

@@ -0,0 +1,7 @@
+import { BaseCommand, type Suggestion } from './base-command.js';
+export declare class PlanSaveCommand extends BaseCommand {
+    name: string;
+    description: string;
+    suggestions: Suggestion[];
+    execute(args: string): Promise<void>;
+}

package/dist/src/commands/plans-command.d.ts

@@ -0,0 +1,21 @@
+import { Plan } from '../test-plan.js';
+import { BaseCommand } from './base-command.js';
+export declare class PlansCommand extends BaseCommand {
+    name: string;
+    description: string;
+    options: {
+        flags: string;
+        description: string;
+    }[];
+    execute(args: string): Promise<void>;
+    getPlanFiles(): PlanFile[];
+    printPlans(files: PlanFile[]): void;
+    printPlanDetails(plan: Plan, file: PlanFile): void;
+    resolvePlanFile(target: string, files: PlanFile[]): PlanFile;
+}
+interface PlanFile {
+    name: string;
+    path: string;
+    modifiedAt: number;
+}
+export {};

package/dist/src/commands/rerun-command.d.ts

@@ -0,0 +1,7 @@
+import { BaseCommand } from './base-command.js';
+export declare class RerunCommand extends BaseCommand {
+    name: string;
+    description: string;
+    tuiEnabled: boolean;
+    execute(args: string): Promise<void>;
+}

package/dist/src/commands/research-command.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand, type Suggestion } from './base-command.js';
+export declare class ResearchCommand extends BaseCommand {
+    name: string;
+    description: string;
+    suggestions: Suggestion[];
+    options: {
+        flags: string;
+        description: string;
+    }[];
+    execute(args: string): Promise<void>;
+}

package/dist/src/commands/runs-command.d.ts

@@ -0,0 +1,7 @@
+import { BaseCommand } from './base-command.js';
+export declare class RunsCommand extends BaseCommand {
+    name: string;
+    description: string;
+    tuiEnabled: boolean;
+    execute(args: string): Promise<void>;
+}

package/dist/src/commands/start-command.d.ts

@@ -0,0 +1,7 @@
+import { BaseCommand, type Suggestion } from './base-command.js';
+export declare class StartCommand extends BaseCommand {
+    name: string;
+    description: string;
+    suggestions: Suggestion[];
+    execute(args: string): Promise<void>;
+}

package/dist/src/commands/status-command.d.ts

@@ -0,0 +1,6 @@
+import { BaseCommand } from './base-command.js';
+export declare class StatusCommand extends BaseCommand {
+    name: string;
+    description: string;
+    execute(_args: string): Promise<void>;
+}

package/dist/src/commands/test-command.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand, type Suggestion } from './base-command.js';
+export declare class TestCommand extends BaseCommand {
+    name: string;
+    description: string;
+    options: {
+        flags: string;
+        description: string;
+    }[];
+    suggestions: Suggestion[];
+    execute(args: string): Promise<void>;
+}

package/dist/src/components/ActivityPane.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface ActivityPaneProps {
+    isInputVisible?: boolean;
+}
+declare const ActivityPane: React.FC<ActivityPaneProps>;
+export default ActivityPane;

package/dist/src/components/AddKnowledge.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { KnowledgeTracker } from '../knowledge-tracker.js';
+interface AddKnowledgeProps {
+    initialUrl?: string;
+    knowledgeTracker: KnowledgeTracker;
+    onComplete?: () => void;
+    onCancel?: () => void;
+}
+declare const AddKnowledge: React.FC<AddKnowledgeProps>;
+export default AddKnowledge;