@isl-lang/repl 0.0.1 → 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,536 @@
+/**
+ * Represents an ISL intent definition
+ */
+interface Intent {
+    name: string;
+    preconditions: Condition[];
+    postconditions: Condition[];
+    invariants: Condition[];
+    scenarios: Scenario[];
+    rawSource: string;
+}
+/**
+ * A condition (pre/post/invariant)
+ */
+interface Condition {
+    expression: string;
+    description?: string;
+}
+/**
+ * A scenario for testing
+ */
+interface Scenario {
+    name: string;
+    given: string[];
+    when: string;
+    then: string[];
+}
+/**
+ * Session configuration
+ */
+interface SessionConfig {
+    colors?: boolean;
+    verbose?: boolean;
+    cwd?: string;
+}
+/**
+ * Session state management for the ISL REPL
+ */
+declare class Session {
+    /** Defined intents in this session */
+    private intents;
+    /** Variables set during the session */
+    private variables;
+    /** Command history */
+    private history;
+    /** Last evaluation result */
+    private lastResult;
+    /** Loaded files */
+    private loadedFiles;
+    /** Session configuration */
+    private config;
+    constructor(config?: SessionConfig);
+    /**
+     * Define a new intent
+     */
+    defineIntent(intent: Intent): void;
+    /**
+     * Get an intent by name
+     */
+    getIntent(name: string): Intent | undefined;
+    /**
+     * Get all defined intents
+     */
+    getAllIntents(): Intent[];
+    /**
+     * Check if an intent exists
+     */
+    hasIntent(name: string): boolean;
+    /**
+     * Remove an intent
+     */
+    removeIntent(name: string): boolean;
+    /**
+     * Get intent names for completion
+     */
+    getIntentNames(): string[];
+    /**
+     * Parse an intent definition from source code
+     */
+    parseIntent(source: string): Intent | null;
+    /**
+     * Set a variable
+     */
+    setVariable(name: string, value: unknown): void;
+    /**
+     * Get a variable
+     */
+    getVariable(name: string): unknown;
+    /**
+     * Get all variables
+     */
+    getAllVariables(): Map<string, unknown>;
+    /**
+     * Check if a variable exists
+     */
+    hasVariable(name: string): boolean;
+    /**
+     * Set the last result (accessible as _)
+     */
+    setLastResult(value: unknown): void;
+    /**
+     * Get the last result
+     */
+    getLastResult(): unknown;
+    /**
+     * Add to history
+     */
+    addToHistory(entry: string): void;
+    /**
+     * Get history
+     */
+    getHistory(count?: number): string[];
+    /**
+     * Load intents from an ISL file
+     */
+    loadFile(filePath: string): Promise<{
+        intents: Intent[];
+        errors: string[];
+    }>;
+    /**
+     * Parse a behavior block as an intent
+     */
+    private parseBehaviorAsIntent;
+    /**
+     * Export session intents to a file
+     */
+    exportToFile(filePath: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Clear all session state
+     */
+    clear(): void;
+    /**
+     * Get session summary
+     */
+    getSummary(): {
+        intentCount: number;
+        variableCount: number;
+        loadedFileCount: number;
+        historyCount: number;
+    };
+    /**
+     * Get loaded files
+     */
+    getLoadedFiles(): string[];
+    /**
+     * Get config
+     */
+    getConfig(): SessionConfig;
+    /**
+     * Update config
+     */
+    setConfig(config: Partial<SessionConfig>): void;
+}
+/**
+ * Create a new session
+ */
+declare function createSession(config?: SessionConfig): Session;
+
+/**
+ * Command history manager with persistence
+ */
+declare class History {
+    private entries;
+    private position;
+    private maxSize;
+    private historyFile;
+    private unsavedCount;
+    private autoSaveThreshold;
+    constructor(options?: {
+        maxSize?: number;
+        historyFile?: string;
+        autoSaveThreshold?: number;
+    });
+    /**
+     * Get default history file path
+     */
+    private getDefaultHistoryFile;
+    /**
+     * Load history from file
+     */
+    load(): void;
+    /**
+     * Save history to file
+     */
+    save(): void;
+    /**
+     * Add entry to history
+     */
+    add(entry: string): void;
+    /**
+     * Get previous entry (for up arrow)
+     */
+    previous(): string | null;
+    /**
+     * Get next entry (for down arrow)
+     */
+    next(): string | null;
+    /**
+     * Reset position to end
+     */
+    resetPosition(): void;
+    /**
+     * Search history for entries containing text
+     */
+    search(text: string): string[];
+    /**
+     * Search backwards from current position
+     */
+    searchBackward(text: string): string | null;
+    /**
+     * Search forward from current position
+     */
+    searchForward(text: string): string | null;
+    /**
+     * Get all entries
+     */
+    getAll(): string[];
+    /**
+     * Get recent entries
+     */
+    getRecent(count: number): string[];
+    /**
+     * Clear history
+     */
+    clear(): void;
+    /**
+     * Get history size
+     */
+    get size(): number;
+    /**
+     * Get current position
+     */
+    get currentPosition(): number;
+}
+/**
+ * In-memory history (no persistence)
+ */
+declare class MemoryHistory extends History {
+    constructor(maxSize?: number);
+    load(): void;
+    save(): void;
+}
+
+interface REPLOptions {
+    colors?: boolean;
+    verbose?: boolean;
+    historyFile?: string;
+}
+/**
+ * ISL REPL - Interactive Read-Eval-Print Loop
+ */
+declare class ISLREPL {
+    private session;
+    private history;
+    private completionProvider;
+    private rl;
+    private buffer;
+    private braceCount;
+    private options;
+    private running;
+    constructor(options?: REPLOptions);
+    /**
+     * Start the REPL
+     */
+    start(): void;
+    /**
+     * Print the welcome banner
+     */
+    private printBanner;
+    /**
+     * Handle a line of input
+     */
+    private handleLine;
+    /**
+     * Handle a meta command (. prefix)
+     */
+    private handleMetaCommand;
+    /**
+     * Handle an ISL command (: prefix)
+     */
+    private handleISLCommand;
+    /**
+     * Evaluate ISL code
+     */
+    private evaluate;
+    /**
+     * Evaluate an intent definition
+     */
+    private evaluateIntent;
+    /**
+     * Print a parse error with location info
+     */
+    private printParseError;
+    /**
+     * Print an error
+     */
+    private printError;
+    /**
+     * Exit the REPL
+     */
+    exit(): void;
+    /**
+     * Get the session
+     */
+    getSession(): Session;
+    /**
+     * Get history
+     */
+    getHistory(): History;
+    /**
+     * Execute a single command and return result (for testing)
+     */
+    executeOnce(input: string): Promise<{
+        success: boolean;
+        output?: string;
+        error?: string;
+    }>;
+}
+/**
+ * Start the REPL
+ */
+declare function startREPL(options?: REPLOptions): ISLREPL;
+
+interface REPL {
+    exit(): void;
+    getSession(): Session;
+}
+/**
+ * Command result
+ */
+interface CommandResult {
+    output?: string;
+    exit?: boolean;
+}
+/**
+ * Meta command definition (. prefix)
+ */
+interface MetaCommand {
+    name: string;
+    aliases: string[];
+    description: string;
+    usage: string;
+    handler: (args: string[], session: Session, repl: REPL) => CommandResult;
+}
+/**
+ * ISL command definition (: prefix)
+ */
+interface ISLCommand {
+    name: string;
+    aliases: string[];
+    description: string;
+    usage: string;
+    handler: (args: string[], session: Session, repl: REPL) => CommandResult;
+}
+declare const metaCommands: MetaCommand[];
+declare const islCommands: ISLCommand[];
+/**
+ * Find a similar command name
+ */
+declare function findSimilarCommand(input: string, type: 'meta' | 'isl'): string | null;
+
+/**
+ * Completion item
+ */
+interface CompletionItem {
+    text: string;
+    type: 'command' | 'intent' | 'keyword' | 'variable' | 'file';
+    description?: string;
+}
+/**
+ * ISL keywords
+ */
+declare const KEYWORDS: CompletionItem[];
+/**
+ * Meta commands (. prefix)
+ */
+declare const META_COMMANDS: CompletionItem[];
+/**
+ * ISL commands (: prefix)
+ */
+declare const ISL_COMMANDS: CompletionItem[];
+/**
+ * All commands
+ */
+declare const COMMANDS: CompletionItem[];
+/**
+ * Provides intelligent completions based on context
+ */
+declare class CompletionProvider {
+    private session;
+    constructor(session: Session);
+    /**
+     * Update the session reference
+     */
+    setSession(session: Session): void;
+    /**
+     * Get completions for a line
+     */
+    complete(line: string): [CompletionItem[], string];
+    /**
+     * Complete meta commands
+     */
+    private completeMetaCommand;
+    /**
+     * Complete ISL commands
+     */
+    private completeISLCommand;
+    /**
+     * Complete :gen command arguments
+     */
+    private completeGenCommand;
+    /**
+     * Complete intent names
+     */
+    private completeIntentName;
+    /**
+     * Complete file paths
+     */
+    private completeFilePath;
+    /**
+     * Complete expressions
+     */
+    private completeExpression;
+    /**
+     * Get all available completions (for help)
+     */
+    getAllCompletions(): {
+        metaCommands: CompletionItem[];
+        islCommands: CompletionItem[];
+        keywords: CompletionItem[];
+        intents: CompletionItem[];
+    };
+}
+/**
+ * Create a readline-compatible completer function
+ */
+declare function createCompleter(provider: CompletionProvider): (line: string) => [string[], string];
+
+declare const colors: {
+    reset: string;
+    bold: string;
+    dim: string;
+    italic: string;
+    underline: string;
+    black: string;
+    red: string;
+    green: string;
+    yellow: string;
+    blue: string;
+    magenta: string;
+    cyan: string;
+    white: string;
+    gray: string;
+    brightRed: string;
+    brightGreen: string;
+    brightYellow: string;
+    brightBlue: string;
+    brightMagenta: string;
+    brightCyan: string;
+    brightWhite: string;
+    bgBlack: string;
+    bgRed: string;
+    bgGreen: string;
+    bgYellow: string;
+    bgBlue: string;
+    bgMagenta: string;
+    bgCyan: string;
+    bgWhite: string;
+};
+/**
+ * Format a success message
+ */
+declare function formatSuccess(message: string): string;
+/**
+ * Format an error message
+ */
+declare function formatError(message: string): string;
+/**
+ * Format a warning message
+ */
+declare function formatWarning(message: string): string;
+/**
+ * Format an info message
+ */
+declare function formatInfo(message: string): string;
+/**
+ * Format an intent for display
+ */
+declare function formatIntent(intent: Intent): string;
+/**
+ * Format a condition
+ */
+declare function formatCondition(condition: Condition, type: 'pre' | 'post' | 'invariant'): string;
+/**
+ * Highlight an ISL expression
+ */
+declare function highlightExpression(expr: string): string;
+/**
+ * Highlight ISL source code
+ */
+declare function highlightISL(source: string): string;
+/**
+ * Format a table
+ */
+declare function formatTable(headers: string[], rows: string[][], options?: {
+    colors?: boolean;
+}): string;
+/**
+ * Format a parse error with caret pointing to position
+ */
+declare function formatParseError(source: string, message: string, line: number, column: number): string;
+/**
+ * Format a type error with expected vs actual
+ */
+declare function formatTypeError(message: string, expected: string, actual: string, context?: string): string;
+/**
+ * Format a value for display
+ */
+declare function formatValue(value: unknown, indent?: number): string;
+/**
+ * Strip ANSI color codes from a string
+ */
+declare function stripColors(str: string): string;
+/**
+ * Wrap text to a maximum width
+ */
+declare function wrapText(text: string, maxWidth: number): string;
+/**
+ * Draw a box around text
+ */
+declare function drawBox(lines: string[], title?: string): string;
+
+export { COMMANDS, type CommandResult, type CompletionItem, CompletionProvider, type Condition, History, type ISLCommand, ISLREPL, ISL_COMMANDS, type Intent, KEYWORDS, META_COMMANDS, MemoryHistory, type MetaCommand, type REPLOptions, type Scenario, Session, type SessionConfig, colors, createCompleter, createSession, drawBox, findSimilarCommand, formatCondition, formatError, formatInfo, formatIntent, formatParseError, formatSuccess, formatTable, formatTypeError, formatValue, formatWarning, highlightExpression, highlightISL, islCommands, metaCommands, startREPL, stripColors, wrapText };