@angriff36/manifest 2.18.0

package/packages/cli/dist/commands/repl.js

@@ -0,0 +1,772 @@
+/**
+ * manifest repl command
+ *
+ * Interactive read-eval-print loop for executing commands, inspecting entity state,
+ * and evaluating expressions against a live runtime loaded from .manifest source.
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import { glob } from 'glob';
+import chalk from 'chalk';
+import ora from 'ora';
+import { createInterface } from 'node:readline';
+// Import from the main Manifest package
+async function loadCompiler() {
+    const module = await import('@angriff36/manifest/ir-compiler');
+    return {
+        compileToIR: module.compileToIR,
+    };
+}
+async function loadRuntime() {
+    const module = await import('@angriff36/manifest');
+    return {
+        RuntimeEngine: module.RuntimeEngine,
+    };
+}
+/**
+ * Get all manifest files from source pattern
+ */
+async function getManifestFiles(source) {
+    if (!source) {
+        const pattern = '**/*.manifest';
+        const files = await glob(pattern, { cwd: process.cwd() });
+        return files.map(f => path.resolve(process.cwd(), f));
+    }
+    const resolved = path.resolve(process.cwd(), source);
+    const stat = await fs.stat(resolved).catch(() => null);
+    if (!stat) {
+        throw new Error(`Source not found: ${source}`);
+    }
+    if (stat.isFile()) {
+        return [resolved];
+    }
+    const pattern = '**/*.manifest';
+    const files = await glob(pattern, { cwd: resolved });
+    return files.map(f => path.resolve(resolved, f));
+}
+/**
+ * Compile a manifest file to IR
+ */
+async function compileManifest(filePath, spinner) {
+    const { compileToIR } = await loadCompiler();
+    spinner.text = `Compiling ${path.relative(process.cwd(), filePath)}`;
+    const source = await fs.readFile(filePath, 'utf-8');
+    const result = await compileToIR(source, { sourcePath: filePath });
+    if (result.diagnostics && result.diagnostics.length > 0) {
+        const errors = result.diagnostics.filter((d) => d.severity === 'error');
+        if (errors.length > 0) {
+            spinner.fail(`Compilation failed with ${errors.length} error(s)`);
+            for (const error of errors) {
+                console.error(chalk.red(`  ${error.message}`));
+            }
+            throw new Error('Compilation failed');
+        }
+    }
+    if (!result.ir) {
+        throw new Error('Compilation produced no IR');
+    }
+    spinner.succeed(`Compiled ${path.relative(process.cwd(), filePath)}`);
+    return result.ir;
+}
+/**
+ * Create a RuntimeEngine instance from IR
+ */
+async function createRuntime(ir, context) {
+    const { RuntimeEngine } = await loadRuntime();
+    return new RuntimeEngine(ir, context);
+}
+/**
+ * Extract a human-readable message from an unknown thrown value.
+ */
+function errorMessage(err) {
+    if (err instanceof Error)
+        return err.message;
+    return String(err);
+}
+/**
+ * Read an optional `description` field that may exist on runtime IR objects
+ * but is not declared on the static IR types.
+ */
+function optionalDescription(obj) {
+    if (obj && typeof obj === 'object' && 'description' in obj) {
+        const value = obj.description;
+        return typeof value === 'string' ? value : undefined;
+    }
+    return undefined;
+}
+/**
+ * Colorize JSON output for better readability
+ */
+function colorizeJSON(obj) {
+    const json = JSON.stringify(obj, null, 2);
+    return json
+        .replace(/(".*?"): ("(.*?)"|(\d+)|(true|false|null))/g, (match, key, value, num, bool) => {
+        const coloredKey = chalk.cyan(key);
+        let coloredValue = value;
+        if (num)
+            coloredValue = chalk.green(num);
+        else if (bool === 'true' || bool === 'false')
+            coloredValue = chalk.yellow(bool);
+        else if (bool === 'null')
+            coloredValue = chalk.gray(bool);
+        else
+            coloredValue = chalk.white(value);
+        return `${coloredKey}: ${coloredValue}`;
+    });
+}
+/**
+ * REPL Commands
+ */
+// HELP: Show all available commands
+const helpCommand = {
+    name: 'help',
+    description: 'Show this help message',
+    handler: async (_args, _context) => {
+        const commands = getAllCommands();
+        let output = '\n' + chalk.bold('Available Commands:') + '\n\n';
+        for (const cmd of commands) {
+            const args = cmd.completer ? ' [...]' : '';
+            output += `  ${chalk.green(cmd.name + args)} - ${chalk.gray(cmd.description)}\n`;
+        }
+        output += '\n' + chalk.bold('Expression Evaluation:') + '\n';
+        output += '  Any input not matching a command is evaluated as a Manifest expression.\n';
+        output += '  Example: `user.role` or `context.tenantId`\n\n';
+        output += chalk.bold('Meta Commands:') + '\n';
+        output += '  `json on|off` - Toggle JSON output mode\n';
+        output += '  `set user <id>` - Set current user\n';
+        output += '  `set tenant <id>` - Set current tenant\n';
+        output += '  `set context <json>` - Set context variables\n\n';
+        output += chalk.bold('Tips:') + '\n';
+        output += '  Use TAB for completion\n';
+        output += '  Use UP/DOWN arrows for command history\n';
+        output += '  Use Ctrl+C or type `exit` to quit\n';
+        return output;
+    },
+};
+// LIST: List all entities
+const listCommand = {
+    name: 'list',
+    description: 'List all entities (aliases: ls, entities)',
+    handler: async (_args, context) => {
+        const entities = context.ir.entities || [];
+        if (context.jsonMode) {
+            return JSON.stringify(entities.map((e) => ({
+                name: e.name,
+                properties: e.properties.length,
+                commands: e.commands.length,
+            })), null, 2);
+        }
+        let output = '\n' + chalk.bold('Entities:') + '\n\n';
+        for (const entity of entities) {
+            output += `  ${chalk.cyan(entity.name)}`;
+            output += chalk.gray(` (${entity.properties.length} properties, ${entity.commands.length} commands)\n`);
+        }
+        return output;
+    },
+    completer: (_args, _context) => [],
+};
+// INSPECT: Show entity details
+const inspectCommand = {
+    name: 'inspect',
+    description: 'Show entity schema, properties, and commands',
+    handler: async (args, context) => {
+        const [entityName] = args;
+        if (!entityName) {
+            return chalk.red('Error: Entity name required\nUsage: inspect <entity-name>');
+        }
+        const entity = context.ir.entities.find((e) => e.name === entityName);
+        if (!entity) {
+            return chalk.red(`Error: Entity '${entityName}' not found`);
+        }
+        if (context.jsonMode) {
+            return JSON.stringify(entity, null, 2);
+        }
+        let output = '\n' + chalk.bold(`Entity: ${chalk.cyan(entity.name)}`) + '\n\n';
+        // Properties
+        output += chalk.bold('Properties:') + '\n';
+        for (const prop of entity.properties) {
+            const isRequired = prop.required;
+            const required = isRequired ? '' : chalk.gray('?');
+            const typeName = prop.type?.name || prop.type || 'unknown';
+            const nullable = prop.type?.nullable ? '?' : '';
+            output += `  ${chalk.yellow(prop.name)}${required}: ${chalk.white(typeName + nullable)}\n`;
+        }
+        // Computed properties
+        if (entity.computedProperties.length > 0) {
+            output += '\n' + chalk.bold('Computed Properties:') + '\n';
+            for (const cp of entity.computedProperties) {
+                output += `  ${chalk.yellow(cp.name)}: ${chalk.gray('(computed)')}\n`;
+            }
+        }
+        // Relationships
+        if (entity.relationships.length > 0) {
+            output += '\n' + chalk.bold('Relationships:') + '\n';
+            for (const rel of entity.relationships) {
+                output += `  ${chalk.yellow(rel.name)}: ${rel.kind} → ${chalk.cyan(rel.target)}\n`;
+            }
+        }
+        // Commands
+        if (entity.commands.length > 0) {
+            output += '\n' + chalk.bold('Commands:') + '\n';
+            for (const cmd of entity.commands) {
+                const command = context.ir.commands.find((c) => c.name === cmd && c.entity === entityName);
+                if (command) {
+                    output += `  ${chalk.green(cmd)}${chalk.gray(' - ' + (optionalDescription(command) || 'No description'))}\n`;
+                }
+                else {
+                    output += `  ${chalk.green(cmd)}\n`;
+                }
+            }
+        }
+        // Constraints
+        if (entity.constraints.length > 0) {
+            output += '\n' + chalk.bold('Constraints:') + '\n';
+            for (const constraint of entity.constraints) {
+                output += `  ${chalk.yellow(constraint.name)}: ${chalk.gray(constraint.code || 'block')}\n`;
+            }
+        }
+        return output;
+    },
+    completer: (_args, context) => {
+        return context.ir.entities.map((e) => e.name);
+    },
+};
+// SHOW: Show entity instances
+const showCommand = {
+    name: 'show',
+    description: 'List all instances of an entity',
+    handler: async (args, context) => {
+        const [entityName] = args;
+        if (!entityName) {
+            return chalk.red('Error: Entity name required\nUsage: show <entity-name>');
+        }
+        const entity = context.ir.entities.find((e) => e.name === entityName);
+        if (!entity) {
+            return chalk.red(`Error: Entity '${entityName}' not found`);
+        }
+        const instances = await context.runtime.getAllInstances(entityName);
+        if (context.jsonMode) {
+            return JSON.stringify(instances, null, 2);
+        }
+        if (instances.length === 0) {
+            return chalk.gray(`No instances of ${chalk.cyan(entityName)} found`);
+        }
+        let output = `\n${chalk.bold(entityName)} instances (${instances.length}):\n\n`;
+        for (const inst of instances) {
+            output += `  ${chalk.green(inst.id)}`;
+            // Show a few key properties
+            const keys = Object.keys(inst).filter(k => k !== 'id' && !k.startsWith('_')).slice(0, 3);
+            if (keys.length > 0) {
+                const preview = keys.map(k => `${k}=${JSON.stringify(inst[k])}`).join(', ');
+                output += chalk.gray(` - ${preview}`);
+            }
+            output += '\n';
+        }
+        return output;
+    },
+    completer: (_args, context) => {
+        return context.ir.entities.map((e) => e.name);
+    },
+};
+// GET: Get a specific instance by ID
+const getCommand = {
+    name: 'get',
+    description: 'Get a specific instance by ID',
+    handler: async (args, context) => {
+        const [entityName, id] = args;
+        if (!entityName || !id) {
+            return chalk.red('Error: Entity name and ID required\nUsage: get <entity-name> <id>');
+        }
+        const entity = context.ir.entities.find((e) => e.name === entityName);
+        if (!entity) {
+            return chalk.red(`Error: Entity '${entityName}' not found`);
+        }
+        const instance = await context.runtime.getInstance(entityName, id);
+        if (!instance) {
+            return chalk.yellow(`Instance ${chalk.green(id)} of ${chalk.cyan(entityName)} not found`);
+        }
+        if (context.jsonMode) {
+            return JSON.stringify(instance, null, 2);
+        }
+        return `\n${chalk.cyan(entityName)} ${chalk.green(id)}:\n${colorizeJSON(instance)}`;
+    },
+    completer: (_args, context) => {
+        return context.ir.entities.map((e) => e.name);
+    },
+};
+// RUN: Execute a command
+const runCommand = {
+    name: 'run',
+    description: 'Execute a manifest command (aliases: exec, execute)',
+    handler: async (args, context) => {
+        const [entityName, commandName, ...inputArgs] = args;
+        if (!entityName || !commandName) {
+            return chalk.red('Error: Entity name and command name required\nUsage: run <entity> <command> [json-input]');
+        }
+        // Parse input JSON if provided
+        let input = {};
+        if (inputArgs.length > 0) {
+            try {
+                const inputStr = inputArgs.join(' ');
+                input = JSON.parse(inputStr);
+            }
+            catch {
+                return chalk.red('Error: Invalid JSON input\nUsage: run <entity> <command> {"key": "value"}');
+            }
+        }
+        const result = await context.runtime.runCommand(commandName, input, {
+            entityName,
+        });
+        if (context.jsonMode) {
+            return JSON.stringify(result, null, 2);
+        }
+        let output = '';
+        if (result.success) {
+            output += chalk.green(`✓ Command ${chalk.cyan(`${entityName}.${commandName}`)} succeeded\n`);
+            if (result.instance) {
+                output += `\n${chalk.bold('Result:')}\n${colorizeJSON(result.instance)}\n`;
+            }
+            else if (result.result !== undefined) {
+                output += `\n${chalk.bold('Result:')}\n${colorizeJSON(result.result)}\n`;
+            }
+        }
+        else {
+            output += chalk.red(`✗ Command ${chalk.cyan(`${entityName}.${commandName}`)} failed\n`);
+            if (result.error) {
+                output += chalk.red(`  Error: ${result.error}\n`);
+            }
+            if (result.deniedBy) {
+                output += chalk.yellow(`  Denied by: ${result.deniedBy}\n`);
+            }
+            if (result.guardFailure) {
+                output += chalk.yellow(`  Guard ${result.guardFailure.index} failed\n`);
+            }
+        }
+        // Show emitted events
+        if (result.emittedEvents && result.emittedEvents.length > 0) {
+            output += `\n${chalk.bold('Emitted Events:')}\n`;
+            for (const event of result.emittedEvents) {
+                output += `  ${chalk.magenta(event.name)} - ${chalk.gray(JSON.stringify(event.payload))}\n`;
+            }
+        }
+        return output;
+    },
+    completer: (args, context) => {
+        if (args.length === 0 || args.length === 1) {
+            return context.ir.entities.map((e) => e.name);
+        }
+        const [entityName] = args;
+        const entity = context.ir.entities.find((e) => e.name === entityName);
+        if (entity && args.length === 2) {
+            return entity.commands;
+        }
+        return [];
+    },
+};
+// CMDS: List all commands in the IR
+const cmdsCommand = {
+    name: 'cmds',
+    description: 'List all commands',
+    handler: async (_args, context) => {
+        const commands = context.ir.commands || [];
+        if (context.jsonMode) {
+            return JSON.stringify(commands, null, 2);
+        }
+        // Group by entity
+        const byEntity = {};
+        for (const cmd of commands) {
+            const entity = cmd.entity || '(global)';
+            if (!byEntity[entity])
+                byEntity[entity] = [];
+            byEntity[entity].push(cmd);
+        }
+        let output = '\n' + chalk.bold('Commands:') + '\n\n';
+        for (const [entity, cmds] of Object.entries(byEntity)) {
+            output += chalk.cyan(entity) + ':\n';
+            for (const cmd of cmds) {
+                output += `  ${chalk.green(cmd.name)}`;
+                const description = optionalDescription(cmd);
+                if (description) {
+                    output += chalk.gray(` - ${description}`);
+                }
+                output += '\n';
+            }
+            output += '\n';
+        }
+        return output;
+    },
+    completer: (_args, _context) => [],
+};
+// EVAL: Evaluate a Manifest expression
+const evalCommand = {
+    name: 'eval',
+    description: 'Evaluate a Manifest expression (use `:eval` for inline evaluation)',
+    handler: async (args, _context) => {
+        const expr = args.join(' ');
+        if (!expr) {
+            return chalk.red('Error: Expression required\nUsage: eval <expression>');
+        }
+        try {
+            // For now, we'll just return the expression as-is
+            // Full expression evaluation would require parsing the expression
+            return chalk.gray(`Expression evaluation not yet implemented for: ${expr}`);
+        }
+        catch (err) {
+            return chalk.red(`Error evaluating expression: ${errorMessage(err)}`);
+        }
+    },
+};
+// SET: Set context variables
+const setCommand = {
+    name: 'set',
+    description: 'Set context variables (user, tenant, context)',
+    handler: async (args, context) => {
+        const [key, ...valueParts] = args;
+        const value = valueParts.join(' ');
+        switch (key) {
+            case 'user':
+                context.userContext.user = { id: value, role: 'user' };
+                return chalk.green(`User set to: ${value}`);
+            case 'tenant':
+                context.userContext.tenantId = value;
+                // Recreate runtime with new tenant context
+                context.runtime = await createRuntime(context.ir, context.userContext);
+                return chalk.green(`Tenant set to: ${value}`);
+            case 'context':
+                try {
+                    const parsed = JSON.parse(value);
+                    context.userContext.context = { ...context.userContext.context, ...parsed };
+                    return chalk.green(`Context updated`);
+                }
+                catch {
+                    return chalk.red('Error: Invalid JSON for context');
+                }
+            default:
+                return chalk.yellow(`Unknown setting: ${key}\nAvailable: user, tenant, context`);
+        }
+    },
+    completer: (_args, _context) => ['user', 'tenant', 'context'],
+};
+// POLICIES: List all policies
+const policiesCommand = {
+    name: 'policies',
+    description: 'List all policies',
+    handler: async (_args, context) => {
+        const policies = context.ir.policies || [];
+        if (context.jsonMode) {
+            return JSON.stringify(policies, null, 2);
+        }
+        let output = '\n' + chalk.bold('Policies:') + '\n\n';
+        for (const policy of policies) {
+            output += `  ${chalk.cyan(policy.name)}`;
+            const description = optionalDescription(policy);
+            if (description) {
+                output += chalk.gray(` - ${description}`);
+            }
+            output += '\n';
+        }
+        return output;
+    },
+};
+// INFO: Show runtime info
+const infoCommand = {
+    name: 'info',
+    description: 'Show runtime and IR information',
+    handler: async (_args, context) => {
+        const provenance = context.ir.provenance;
+        if (context.jsonMode) {
+            return JSON.stringify({
+                manifestPath: context.manifestPath,
+                compilerVersion: provenance?.compilerVersion,
+                schemaVersion: provenance?.schemaVersion,
+                compiledAt: provenance?.compiledAt,
+                entities: context.ir.entities.length,
+                commands: context.ir.commands.length,
+                policies: context.ir.policies.length,
+                tenant: context.ir.tenant,
+            }, null, 2);
+        }
+        let output = '\n' + chalk.bold('Runtime Information') + '\n\n';
+        output += `  ${chalk.yellow('Manifest:')} ${context.manifestPath}\n`;
+        output += `  ${chalk.yellow('Compiler:')} ${provenance?.compilerVersion || 'unknown'}\n`;
+        output += `  ${chalk.yellow('Schema:')} ${provenance?.schemaVersion || 'unknown'}\n`;
+        output += `  ${chalk.yellow('Compiled:')} ${provenance?.compiledAt || 'unknown'}\n\n`;
+        output += `  ${chalk.yellow('Entities:')} ${context.ir.entities.length}\n`;
+        output += `  ${chalk.yellow('Commands:')} ${context.ir.commands.length}\n`;
+        output += `  ${chalk.yellow('Policies:')} ${context.ir.policies.length}\n`;
+        if (context.ir.tenant) {
+            output += `  ${chalk.yellow('Tenant:')} ${context.ir.tenant.property}\n`;
+        }
+        // Show current context
+        output += '\n' + chalk.bold('Current Context:') + '\n';
+        if (context.userContext.user) {
+            output += `  ${chalk.yellow('User:')} ${context.userContext.user.id}\n`;
+        }
+        if (context.userContext.tenantId) {
+            output += `  ${chalk.yellow('Tenant ID:')} ${context.userContext.tenantId}\n`;
+        }
+        output += `  ${chalk.yellow('JSON Mode:')} ${context.jsonMode ? 'on' : 'off'}\n`;
+        return output;
+    },
+};
+// CLEAR: Clear event log
+const clearCommand = {
+    name: 'clear',
+    description: 'Clear the event log (aliases: cls)',
+    handler: async (_args, context) => {
+        context.runtime.clearEventLog();
+        return chalk.green('Event log cleared');
+    },
+};
+// EVENTS: Show event log
+const eventsCommand = {
+    name: 'events',
+    description: 'Show event log',
+    handler: async (_args, context) => {
+        const events = context.runtime.getEventLog();
+        if (context.jsonMode) {
+            return JSON.stringify(events, null, 2);
+        }
+        if (events.length === 0) {
+            return chalk.gray('No events logged yet');
+        }
+        let output = `\n${chalk.bold('Event Log')} (${events.length} events):\n\n`;
+        for (const event of events) {
+            output += `  ${chalk.magenta(event.name)} - ${chalk.gray(JSON.stringify(event.payload))}\n`;
+        }
+        return output;
+    },
+};
+// EXIT: Exit the REPL
+const exitCommand = {
+    name: 'exit',
+    description: 'Exit the REPL (aliases: quit, q)',
+    handler: async () => {
+        return '__EXIT__';
+    },
+};
+// JSON: Toggle JSON output mode
+const jsonToggleCommand = {
+    name: 'json',
+    description: 'Toggle JSON output mode',
+    handler: async (args, context) => {
+        const [mode] = args;
+        if (mode === 'on' || mode === 'true' || mode === '1') {
+            context.jsonMode = true;
+            return chalk.green('JSON mode: ON');
+        }
+        else if (mode === 'off' || mode === 'false' || mode === '0') {
+            context.jsonMode = false;
+            return chalk.green('JSON mode: OFF');
+        }
+        else {
+            context.jsonMode = !context.jsonMode;
+            return chalk.green(`JSON mode: ${context.jsonMode ? 'ON' : 'OFF'}`);
+        }
+    },
+    completer: (_args, _context) => ['on', 'off'],
+};
+// Reload: Reload the manifest file
+const reloadCommand = {
+    name: 'reload',
+    description: 'Reload the manifest file',
+    handler: async (args, context) => {
+        const spinner = ora('Reloading manifest').start();
+        try {
+            const ir = await compileManifest(context.manifestPath, spinner);
+            context.ir = ir;
+            context.runtime = await createRuntime(ir, context.userContext);
+            return chalk.green('Manifest reloaded successfully');
+        }
+        catch (err) {
+            spinner.fail('Reload failed');
+            return chalk.red(`Error: ${errorMessage(err)}`);
+        }
+    },
+};
+// Get all commands with aliases
+function getAllCommands() {
+    return [
+        helpCommand,
+        listCommand,
+        inspectCommand,
+        showCommand,
+        getCommand,
+        runCommand,
+        cmdsCommand,
+        evalCommand,
+        setCommand,
+        policiesCommand,
+        infoCommand,
+        clearCommand,
+        eventsCommand,
+        jsonToggleCommand,
+        reloadCommand,
+        exitCommand,
+    ];
+}
+// Command lookup by name (including aliases)
+const commandAliases = {
+    'ls': 'list',
+    'entities': 'list',
+    'exec': 'run',
+    'execute': 'run',
+    'quit': 'exit',
+    'q': 'exit',
+    'cls': 'clear',
+};
+function findCommand(name) {
+    const canonicalName = commandAliases[name] || name;
+    return getAllCommands().find(c => c.name === canonicalName);
+}
+/**
+ * Parse input line into command and arguments
+ */
+function parseInput(line) {
+    const trimmed = line.trim();
+    // Check for special "json on|off" syntax
+    if (trimmed.startsWith('json ')) {
+        const parts = trimmed.slice(4).trim().split(/\s+/);
+        return { command: 'json', args: parts, raw: trimmed };
+    }
+    // Check for "set user/tenant/context" syntax
+    if (trimmed.startsWith('set ')) {
+        const parts = trimmed.slice(4).trim().split(/\s+/);
+        return { command: 'set', args: parts, raw: trimmed };
+    }
+    // Check for ":eval" inline evaluation syntax
+    if (trimmed.startsWith(':eval ')) {
+        const expr = trimmed.slice(6).trim();
+        return { command: 'eval', args: [expr], raw: trimmed };
+    }
+    // Regular command parsing
+    const parts = trimmed.split(/\s+/);
+    const command = parts[0];
+    const args = parts.slice(1);
+    return { command, args, raw: trimmed };
+}
+/**
+ * Create readline interface with completion
+ */
+function createReadline(context) {
+    return createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        completer: (line) => {
+            const { command, args } = parseInput(line);
+            const cmd = findCommand(command);
+            if (cmd && cmd.completer) {
+                const completions = cmd.completer(args, context);
+                const lastArg = args[args.length - 1] || '';
+                const hits = completions.filter((c) => c.startsWith(lastArg));
+                // Show all completions if no input, or filter by input
+                if (args.length === 0) {
+                    return [completions, line];
+                }
+                return [hits.length ? hits : completions, line];
+            }
+            // Complete command names
+            if (args.length === 0) {
+                const commands = getAllCommands().map(c => c.name);
+                const hits = commands.filter(c => c.startsWith(command));
+                return [hits.length ? hits : commands, line];
+            }
+            return [[], line];
+        },
+        prompt: chalk.cyan('manifest') + chalk.gray('>') + ' ',
+    });
+}
+/**
+ * Main REPL loop
+ */
+async function replLoop(context) {
+    const rl = createReadline(context);
+    // Show welcome message
+    console.log('');
+    console.log(chalk.bold.green('Manifest REPL') + chalk.gray(' - Interactive Runtime'));
+    console.log(chalk.gray('Type `help` for available commands, `exit` to quit'));
+    console.log('');
+    rl.prompt();
+    for await (const line of rl) {
+        if (line.trim() === '') {
+            rl.prompt();
+            continue;
+        }
+        try {
+            const { command, args } = parseInput(line);
+            const cmd = findCommand(command);
+            if (cmd) {
+                const result = await cmd.handler(args, context);
+                if (result === '__EXIT__') {
+                    rl.close();
+                    break;
+                }
+                if (result) {
+                    console.log(result);
+                }
+            }
+            else {
+                // Not a recognized command - could be an expression evaluation
+                // For now, show an error
+                console.log(chalk.yellow(`Unknown command: ${command}`));
+                console.log(chalk.gray('Type `help` for available commands'));
+            }
+        }
+        catch (err) {
+            console.error(chalk.red(`Error: ${errorMessage(err)}`));
+        }
+        rl.prompt();
+    }
+}
+/**
+ * Main entry point for the repl command
+ */
+export async function replCommand(source, options = {}) {
+    // Find and compile manifest file
+    const files = await getManifestFiles(source || '');
+    if (files.length === 0) {
+        console.error(chalk.red('Error: No .manifest files found'));
+        console.log(chalk.gray('Create a .manifest file or specify a source path'));
+        process.exit(1);
+    }
+    // Use the first file found
+    const manifestPath = files[0];
+    const spinner = ora('Loading manifest').start();
+    try {
+        const ir = await compileManifest(manifestPath, spinner);
+        // Build user context
+        const userContext = {
+            user: options.user ? { id: options.user, role: 'user' } : { id: 'repl-user', role: 'user' },
+        };
+        if (options.tenant) {
+            userContext.tenantId = options.tenant;
+        }
+        if (options.context) {
+            try {
+                userContext.context = JSON.parse(options.context);
+            }
+            catch {
+                spinner.warn('Invalid JSON for --context, ignoring');
+            }
+        }
+        // Create runtime
+        const runtime = await createRuntime(ir, userContext);
+        // Set up REPL context
+        const replContext = {
+            ir,
+            runtime,
+            manifestPath,
+            jsonMode: options.json || false,
+            userContext,
+        };
+        spinner.stop();
+        // Start REPL loop
+        await replLoop(replContext);
+    }
+    catch (err) {
+        spinner.fail('Failed to load manifest');
+        console.error(chalk.red(errorMessage(err)));
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=repl.js.map