@isl-lang/repl 0.0.1 → 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,589 @@
+/**
+ * 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;
+    /** Evaluation context (set by .context command) */
+    private evalContext;
+    /** Pre-state context for old() expressions */
+    private preContext;
+    /** Loaded domain AST (from real parser) */
+    private domainAST;
+    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;
+    }>;
+    /**
+     * Set evaluation context from JSON string
+     */
+    setEvalContext(json: string): {
+        success: boolean;
+        count: number;
+        error?: string;
+    };
+    /**
+     * Set pre-state context for old() expressions
+     */
+    setPreContext(json: string): {
+        success: boolean;
+        error?: string;
+    };
+    /**
+     * Get evaluation context
+     */
+    getEvalContext(): Record<string, unknown>;
+    /**
+     * Get pre-state context
+     */
+    getPreContext(): Record<string, unknown> | null;
+    /**
+     * Resolve a dot-path against the evaluation context
+     */
+    resolveValue(dotPath: string): {
+        found: boolean;
+        value: unknown;
+    };
+    /**
+     * Resolve a dot-path against the pre-state context
+     */
+    resolvePreValue(dotPath: string): {
+        found: boolean;
+        value: unknown;
+    };
+    /**
+     * Set domain AST (from real parser)
+     */
+    setDomainAST(ast: unknown): void;
+    /**
+     * Get domain AST
+     */
+    getDomainAST(): unknown;
+    /**
+     * 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;
+    /** Load an ISL file on startup */
+    load?: string;
+    /** Set initial evaluation context (JSON string) */
+    context?: string;
+    /** Parse-only mode (non-interactive, for piped input) */
+    parseOnly?: boolean;
+}
+/**
+ * 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;
+    /**
+     * Apply startup options (--load, --context)
+     */
+    private applyStartupOptions;
+    /**
+     * Run in pipe mode (read all stdin, parse, and output)
+     */
+    private runPipeMode;
+    /**
+     * Print the welcome banner
+     */
+    private printBanner;
+    /**
+     * Handle a line of input
+     */
+    handleLine(line: string): void;
+    /**
+     * Handle a dot command (. prefix)
+     */
+    private handleDotCommand;
+    /**
+     * Evaluate ISL code (multi-line input or bare expressions)
+     */
+    private evaluate;
+    /**
+     * Evaluate an intent definition
+     */
+    private evaluateIntent;
+    /**
+     * 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;
+}
+type ISLCommand = MetaCommand;
+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 (kept empty for backward compat — all commands use . 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;
+
+/**
+ * Main entry point
+ */
+declare function main(): void;
+
+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, main, metaCommands, startREPL, stripColors, wrapText };