@schema-weaver/pg-connector 0.0.0-stage → 2.0.1

package/dist/cjs/cli/interactive.js

@@ -0,0 +1,670 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PALETTE_ITEMS = void 0;
+exports.dispatchCommand = dispatchCommand;
+exports.startInteractive = startInteractive;
+const node_process_1 = require("node:process");
+const banner_1 = require("./banner");
+const prompt_1 = require("./prompt");
+const init_1 = require("./commands/init");
+const db_1 = require("./commands/db");
+const project_1 = require("./commands/project");
+const agent_1 = require("./commands/agent");
+const doctor_1 = require("./commands/doctor");
+const logs_1 = require("./commands/logs");
+const audit_verify_1 = require("./commands/audit-verify");
+const config_1 = require("./commands/config");
+const link_1 = require("./commands/link");
+const ui_1 = require("./ui");
+const PROMPT = ui_1.C.brand('sw-agent') + ui_1.C.gray(' > ');
+const COMMANDS = [
+    {
+        name: 'db list',
+        desc: 'List configured databases',
+        category: 'Databases',
+        action: (a) => (0, db_1.runDbList)(a),
+        aliases: ['ls'],
+    },
+    {
+        name: 'db show',
+        desc: 'Show database details & live status',
+        category: 'Databases',
+        action: (a) => (0, db_1.runDbShow)(a),
+        aliases: ['info'],
+    },
+    {
+        name: 'db add',
+        desc: 'Add a database',
+        category: 'Databases',
+        action: (a) => (0, db_1.runDbAdd)(a),
+        aliases: ['add'],
+    },
+    {
+        name: 'db edit',
+        desc: 'Edit a database entry',
+        category: 'Databases',
+        action: (a) => (0, db_1.runDbEdit)(a),
+        aliases: ['edit'],
+    },
+    {
+        name: 'db remove',
+        desc: 'Remove a database entry',
+        category: 'Databases',
+        action: (a) => (0, db_1.runDbRemove)(a),
+        aliases: ['rm'],
+    },
+    {
+        name: 'db test',
+        desc: 'Test database connection',
+        category: 'Databases',
+        action: (a) => (0, db_1.runDbTest)(a),
+        aliases: ['test'],
+    },
+    {
+        name: 'db ping',
+        desc: 'Ping database connection latency',
+        category: 'Databases',
+        action: (a) => (0, db_1.runDbPing)(a),
+        aliases: ['ping'],
+    },
+    {
+        name: 'db connect',
+        desc: 'Open interactive SQL console (classified, audited)',
+        category: 'Databases',
+        action: (a) => (0, db_1.runDbConnect)(a),
+        aliases: ['connect'],
+    },
+    {
+        name: 'db query',
+        desc: 'Execute SQL query against database (permission-checked)',
+        category: 'Databases',
+        action: (a) => (0, db_1.runDbQuery)(a),
+        aliases: ['query'],
+    },
+    {
+        name: 'db logs',
+        desc: 'View audit logs for a database',
+        category: 'Databases',
+        action: (a) => (0, db_1.runDbLogs)(a),
+    },
+    {
+        name: 'project list',
+        desc: 'List linked projects',
+        category: 'Projects',
+        action: (a) => (0, project_1.runProjectList)(a),
+        aliases: ['projects'],
+    },
+    {
+        name: 'project show',
+        desc: 'Show project details',
+        category: 'Projects',
+        action: (a) => (0, project_1.runProjectShow)(a),
+    },
+    {
+        name: 'agent start',
+        desc: 'Start the daemon',
+        category: 'Agent',
+        action: (a) => (0, agent_1.runStart)(a),
+        aliases: ['start', 'up'],
+    },
+    {
+        name: 'agent stop',
+        desc: 'Stop the daemon',
+        category: 'Agent',
+        action: (a) => (0, agent_1.runStop)(a),
+        aliases: ['stop', 'down'],
+    },
+    {
+        name: 'agent restart',
+        desc: 'Restart the daemon',
+        category: 'Agent',
+        action: (a) => (0, agent_1.runRestart)(a),
+        aliases: ['restart'],
+    },
+    {
+        name: 'agent status',
+        desc: 'Show agent status',
+        category: 'Agent',
+        action: (a) => (0, agent_1.runStatus)(a),
+        aliases: ['status', 'ps', 'top'],
+    },
+    {
+        name: 'agent clean',
+        desc: 'Clean daemon & stale PID/status files',
+        category: 'Agent',
+        action: (a) => (0, agent_1.runClean)(a),
+        aliases: ['clean', 'kill'],
+    },
+    { name: 'init', desc: 'First-time setup', category: 'Setup', action: (a) => (0, init_1.runInit)(a) },
+    {
+        name: 'doctor',
+        desc: 'Run diagnostics',
+        category: 'Setup',
+        action: (a) => (0, doctor_1.runDoctor)(a),
+        aliases: ['doc'],
+    },
+    {
+        name: 'config show',
+        desc: 'Show machine configuration',
+        category: 'Setup',
+        action: (a) => (0, config_1.runConfigShow)(a),
+        aliases: ['config', 'conf', 'cfg'],
+    },
+    {
+        name: 'config get',
+        desc: 'Get a configuration setting',
+        category: 'Setup',
+        action: (a) => (0, config_1.runConfigGet)(a),
+    },
+    {
+        name: 'config set',
+        desc: 'Update a configuration setting',
+        category: 'Setup',
+        action: (a) => (0, config_1.runConfigSet)(a),
+    },
+    {
+        name: 'config path',
+        desc: 'Show config and state file paths',
+        category: 'Setup',
+        action: () => (0, config_1.runConfigPath)(),
+    },
+    {
+        name: 'link',
+        desc: 'Pairing stub for browser projects',
+        category: 'Setup',
+        action: (a) => (0, link_1.runLink)(a),
+    },
+    {
+        name: 'logs',
+        desc: 'Interactive audit log browser & viewer',
+        category: 'Ops',
+        action: (a) => (0, logs_1.runLogs)(a),
+        aliases: ['log'],
+    },
+    {
+        name: 'audit verify',
+        desc: 'Verify audit chain integrity',
+        category: 'Ops',
+        action: (a) => (0, audit_verify_1.runAuditVerify)(a),
+        aliases: ['verify'],
+    },
+    { name: 'help', desc: 'Show help', category: 'Ops', action: () => showHelp() },
+    {
+        name: 'clear',
+        desc: 'Clear screen',
+        category: 'Ops',
+        action: async () => {
+            (0, ui_1.clearScreen)();
+            (0, banner_1.printBanner)();
+        },
+    },
+    { name: 'exit', desc: 'Quit', category: 'Ops', action: async () => { } },
+];
+exports.PALETTE_ITEMS = COMMANDS.map((c) => ({
+    command: c.name,
+    desc: c.desc,
+    category: c.category,
+}));
+const ALIAS_MAP = new Map();
+for (const cmd of COMMANDS) {
+    for (const alias of cmd.aliases ?? []) {
+        ALIAS_MAP.set(alias, cmd.name);
+    }
+}
+function findCommand(input) {
+    // Category fallbacks
+    if (input === 'db')
+        return COMMANDS.find((c) => c.name === 'db list') ?? null;
+    if (input === 'agent')
+        return COMMANDS.find((c) => c.name === 'agent status') ?? null;
+    if (input === 'project')
+        return COMMANDS.find((c) => c.name === 'project list') ?? null;
+    if (input === 'audit')
+        return COMMANDS.find((c) => c.name === 'audit verify') ?? null;
+    const exact = COMMANDS.find((c) => c.name === input);
+    if (exact)
+        return exact;
+    const alias = ALIAS_MAP.get(input);
+    if (alias) {
+        return COMMANDS.find((c) => c.name === alias) ?? null;
+    }
+    const legacy = input.replace(/:/g, ' ');
+    const legacyCmd = COMMANDS.find((c) => c.name === legacy);
+    if (legacyCmd)
+        return legacyCmd;
+    const matches = COMMANDS.filter((c) => c.name.startsWith(input));
+    return matches.length === 1 ? matches[0] : null;
+}
+async function showHelp() {
+    console.log();
+    console.log(ui_1.C.bold('  Commands'));
+    console.log();
+    const categories = ['Databases', 'Projects', 'Agent', 'Setup', 'Ops'];
+    for (const cat of categories) {
+        console.log(ui_1.C.brand(`  ${cat}`));
+        for (const cmd of COMMANDS.filter((c) => c.category === cat)) {
+            const aliasStr = cmd.aliases?.length ? ui_1.C.dim(` (${cmd.aliases.join(', ')})`) : '';
+            console.log(`    ${ui_1.C.cyan(cmd.name.padEnd(18))}  ${ui_1.C.dim(cmd.desc)}${aliasStr}`);
+        }
+        console.log();
+    }
+    console.log(`  ${ui_1.C.dim('Type')} ${ui_1.C.cyan('/')} ${ui_1.C.dim('to open the command palette.')}`);
+    console.log(`  ${ui_1.C.dim('Type')} ${ui_1.C.cyan('exit')} ${ui_1.C.dim('to quit.')}`);
+    console.log();
+}
+async function runCommand(fn) {
+    try {
+        await fn();
+    }
+    catch (err) {
+        if (err && typeof err === 'object' && '__exitCode' in err) {
+            return;
+        }
+        console.log(`  ${ui_1.C.red('Error:')} ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+async function dispatchCommand(input) {
+    const trimmed = input.trim();
+    if (!trimmed)
+        return 'continue';
+    if (trimmed === 'exit' || trimmed === 'quit')
+        return 'exit';
+    if (trimmed === 'help') {
+        await showHelp();
+        return 'continue';
+    }
+    if (trimmed === 'clear') {
+        (0, ui_1.clearScreen)();
+        (0, banner_1.printBanner)();
+        return 'continue';
+    }
+    if (trimmed.includes(':')) {
+        const legacy = trimmed.replace(/:/g, ' ');
+        if (findCommand(legacy)) {
+            console.log(`  ${ui_1.C.yellow('Deprecated:')} ${ui_1.C.dim(trimmed)} -> use ${ui_1.C.cyan(legacy)} instead`);
+        }
+    }
+    const parts = trimmed.split(/\s+/);
+    let cmd = null;
+    let args = [];
+    for (let wordCount = Math.min(parts.length, 3); wordCount >= 1; wordCount--) {
+        const candidate = parts.slice(0, wordCount).join(' ');
+        const found = findCommand(candidate);
+        if (found) {
+            cmd = found;
+            args = parts.slice(wordCount);
+            break;
+        }
+    }
+    if (!cmd) {
+        console.log(`  ${ui_1.C.yellow('Unknown command:')} ${ui_1.C.white(trimmed)}`);
+        console.log(`  ${ui_1.C.dim('Type')} ${ui_1.C.cyan('/')} ${ui_1.C.dim('for suggestions or')} ${ui_1.C.cyan('help')} ${ui_1.C.dim('for commands.')}`);
+        return 'continue';
+    }
+    if (cmd.name === 'exit')
+        return 'exit';
+    await runCommand(() => cmd.action(args));
+    if (cmd.name === 'agent start' ||
+        cmd.name === 'agent stop' ||
+        cmd.name === 'agent restart' ||
+        cmd.name === 'agent clean') {
+        await runCommand(() => (0, agent_1.runStatus)([]));
+    }
+    return 'continue';
+}
+class TerminalRepl {
+    buffer = '';
+    cursor = 0;
+    palette = null;
+    isExecuting = false;
+    renderedLines = 0;
+    resizeTimer = null;
+    resolve;
+    onDataBound = this.onKey.bind(this);
+    onResizeBound = this.onResize.bind(this);
+    async run() {
+        (0, banner_1.printBanner)();
+        (0, prompt_1.setReplMode)(true);
+        node_process_1.stdout.write(`  ${ui_1.C.dim('Type')} ${ui_1.C.cyan('/')} ${ui_1.C.dim('for commands,')} ${ui_1.C.cyan('help')} ${ui_1.C.dim('for help,')} ${ui_1.C.cyan('exit')} ${ui_1.C.dim('to quit.')}\n\n`);
+        if (node_process_1.stdin.isTTY) {
+            node_process_1.stdin.setRawMode(true);
+        }
+        node_process_1.stdin.resume();
+        node_process_1.stdin.on('data', this.onDataBound);
+        node_process_1.stdout.on('resize', this.onResizeBound);
+        this.render();
+        return new Promise((resolve) => {
+            this.resolve = resolve;
+        });
+    }
+    onResize() {
+        if (this.resizeTimer)
+            clearTimeout(this.resizeTimer);
+        this.resizeTimer = setTimeout(() => this.render(), 50);
+    }
+    onKey(chunk) {
+        if (this.isExecuting)
+            return;
+        const sequences = splitInput(chunk.toString('utf8'));
+        for (const token of sequences) {
+            if (this.handleToken(token))
+                return;
+        }
+        this.render();
+    }
+    handleToken(token) {
+        if (token === '\x03') {
+            this.shutdown();
+            return true;
+        }
+        if (token === '\r' || token === '\n') {
+            if (this.palette) {
+                const match = this.filteredPalette()[this.palette.selected];
+                if (match) {
+                    this.buffer = match.command;
+                    this.cursor = this.buffer.length;
+                    this.palette = null;
+                    this.render();
+                    this.submit();
+                }
+                return true;
+            }
+            this.submit();
+            return true;
+        }
+        if (token === '\x1b') {
+            if (this.palette && this.buffer.startsWith('/')) {
+                this.buffer = '';
+                this.cursor = 0;
+            }
+            this.palette = null;
+            return false;
+        }
+        if (token === '\x7f' || token === '\b') {
+            this.backspace();
+            return false;
+        }
+        if (token === '\t') {
+            if (this.palette) {
+                this.movePalette(1);
+            }
+            return false;
+        }
+        if (token === '\x1b[A') {
+            if (this.palette)
+                this.movePalette(-1);
+            return false;
+        }
+        if (token === '\x1b[B') {
+            if (this.palette)
+                this.movePalette(1);
+            return false;
+        }
+        if (token === '\x1b[D') {
+            this.cursor = Math.max(0, this.cursor - 1);
+            return false;
+        }
+        if (token === '\x1b[C') {
+            this.cursor = Math.min(this.buffer.length, this.cursor + 1);
+            return false;
+        }
+        if (token === '\x1b[H' || token === '\x1b[1~') {
+            this.cursor = 0;
+            return false;
+        }
+        if (token === '\x1b[F' || token === '\x1b[4~') {
+            this.cursor = this.buffer.length;
+            return false;
+        }
+        if (token === '\x1b[3~') {
+            this.deleteForward();
+            return false;
+        }
+        if (/^[ -~]$/.test(token)) {
+            this.insert(token);
+        }
+        return false;
+    }
+    insert(ch) {
+        this.buffer = this.buffer.slice(0, this.cursor) + ch + this.buffer.slice(this.cursor);
+        this.cursor += ch.length;
+        if (this.buffer.startsWith('/')) {
+            this.palette = {
+                query: this.buffer.slice(1).trimStart(),
+                selected: 0,
+                scroll: 0,
+            };
+        }
+    }
+    backspace() {
+        if (this.cursor <= 0)
+            return;
+        this.buffer = this.buffer.slice(0, this.cursor - 1) + this.buffer.slice(this.cursor);
+        this.cursor -= 1;
+        if (this.palette) {
+            if (!this.buffer.startsWith('/')) {
+                this.palette = null;
+            }
+            else {
+                this.palette.query = this.buffer.slice(1).trimStart();
+                this.palette.selected = 0;
+                this.palette.scroll = 0;
+                if (this.palette.query === '' && this.buffer === '') {
+                    this.palette = null;
+                }
+            }
+        }
+    }
+    deleteForward() {
+        if (this.cursor >= this.buffer.length)
+            return;
+        this.buffer = this.buffer.slice(0, this.cursor) + this.buffer.slice(this.cursor + 1);
+        if (this.palette) {
+            this.palette.query = this.buffer.startsWith('/') ? this.buffer.slice(1).trimStart() : '';
+        }
+    }
+    movePalette(delta) {
+        if (!this.palette)
+            return;
+        const matches = this.filteredPalette();
+        if (matches.length === 0)
+            return;
+        this.palette.selected = Math.max(0, Math.min(matches.length - 1, this.palette.selected + delta));
+        const height = this.paletteHeight();
+        if (this.palette.selected < this.palette.scroll) {
+            this.palette.scroll = this.palette.selected;
+        }
+        else if (this.palette.selected >= this.palette.scroll + height) {
+            this.palette.scroll = this.palette.selected - height + 1;
+        }
+    }
+    async submit() {
+        const input = this.buffer.trim();
+        this.palette = null;
+        if (!input) {
+            this.render();
+            return;
+        }
+        this.clearRenderedBlock();
+        node_process_1.stdout.write(`${PROMPT}${this.buffer}\n`);
+        this.buffer = '';
+        this.cursor = 0;
+        this.isExecuting = true;
+        this.setRawMode(false);
+        let result = 'continue';
+        try {
+            result = await dispatchCommand(input);
+        }
+        finally {
+            this.setRawMode(true);
+            this.isExecuting = false;
+        }
+        if (result === 'exit') {
+            this.shutdown();
+            return;
+        }
+        this.render();
+    }
+    filteredPalette() {
+        if (!this.palette)
+            return exports.PALETTE_ITEMS;
+        const q = this.palette.query.toLowerCase();
+        if (!q)
+            return exports.PALETTE_ITEMS;
+        return exports.PALETTE_ITEMS.map((item) => ({ item, score: rankPalette(q, item) }))
+            .filter(({ score }) => score < 50)
+            .sort((a, b) => a.score - b.score || a.item.command.localeCompare(b.item.command))
+            .map(({ item }) => item);
+    }
+    paletteHeight() {
+        const rows = Math.max(3, Math.min(8, Math.floor((process.stdout.rows || 24) / 3)));
+        return rows;
+    }
+    renderPalette() {
+        if (!this.palette)
+            return [];
+        const width = Math.max(28, Math.min(64, (0, ui_1.terminalWidth)() - 4));
+        const inner = width - 2;
+        const matches = this.filteredPalette();
+        const height = this.paletteHeight();
+        const visible = matches.slice(this.palette.scroll, this.palette.scroll + height);
+        const lines = [];
+        const title = this.palette.query ? ` Commands matching "${this.palette.query}" ` : ' Commands ';
+        const titleWidth = Math.min((0, ui_1.visibleLength)(title), inner - 2);
+        lines.push(ui_1.C.cyan(ui_1.S.tl +
+            ui_1.S.h +
+            (0, ui_1.truncateAnsi)(title, titleWidth) +
+            ui_1.S.h.repeat(Math.max(0, inner - titleWidth - 1)) +
+            ui_1.S.tr));
+        if (visible.length === 0) {
+            lines.push(ui_1.C.cyan(ui_1.S.v) + ' ' + (0, ui_1.alignAnsi)(ui_1.C.dim('No matches'), inner - 1) + ui_1.C.cyan(ui_1.S.v));
+        }
+        else {
+            for (let i = 0; i < height; i++) {
+                const item = visible[i];
+                if (!item) {
+                    lines.push(ui_1.C.cyan(ui_1.S.v) + ' '.repeat(inner) + ui_1.C.cyan(ui_1.S.v));
+                    continue;
+                }
+                const index = this.palette.scroll + i;
+                const selected = index === this.palette.selected;
+                const marker = selected ? ui_1.C.brand(ui_1.S.right) : ' ';
+                const cmdWidth = Math.min(22, Math.max(12, Math.floor(inner * 0.42)));
+                const descWidth = Math.max(8, inner - cmdWidth - 5);
+                const cmd = selected ? ui_1.C.bold(ui_1.C.brand(item.command)) : ui_1.C.cyan(item.command);
+                const desc = selected ? ui_1.C.white(item.desc) : ui_1.C.dim(item.desc);
+                const body = ` ${marker} ` +
+                    (0, ui_1.alignAnsi)((0, ui_1.truncateAnsi)(cmd, cmdWidth, ui_1.S.ellipsis), cmdWidth) +
+                    '  ' +
+                    (0, ui_1.alignAnsi)((0, ui_1.truncateAnsi)(desc, descWidth, ui_1.S.ellipsis), descWidth);
+                const fitted = (0, ui_1.truncateAnsi)(body, inner, '');
+                lines.push(ui_1.C.cyan(ui_1.S.v) +
+                    fitted +
+                    ' '.repeat(Math.max(0, inner - (0, ui_1.visibleLength)(fitted))) +
+                    ui_1.C.cyan(ui_1.S.v));
+            }
+        }
+        const total = matches.length;
+        const start = total === 0 ? 0 : this.palette.selected + 1;
+        const footer = ` ${start}/${total}  Enter select  Esc cancel  Backspace close `;
+        lines.push(ui_1.C.cyan(ui_1.S.bl + ui_1.S.h.repeat(inner) + ui_1.S.br));
+        lines.push(ui_1.C.dim('  ' + (0, ui_1.truncateAnsi)(footer.trim(), width - 2)));
+        return lines;
+    }
+    render() {
+        this.clearRenderedBlock();
+        const lines = this.renderPalette();
+        for (const line of lines) {
+            node_process_1.stdout.write((0, ui_1.fitLine)(line) + '\n');
+        }
+        const promptLine = PROMPT + this.buffer;
+        node_process_1.stdout.write('\r\x1b[2K' + (0, ui_1.fitLine)(promptLine));
+        this.renderedLines = lines.length + 1;
+        const cursorColumn = (0, ui_1.visibleLength)(PROMPT) + this.cursor;
+        if (cursorColumn > 0) {
+            node_process_1.stdout.write(`\r\x1b[${cursorColumn}C`);
+        }
+    }
+    clearRenderedBlock() {
+        if (this.renderedLines === 0)
+            return;
+        node_process_1.stdout.write('\r\x1b[2K');
+        for (let i = 1; i < this.renderedLines; i++) {
+            node_process_1.stdout.write('\x1b[1A\x1b[2K');
+        }
+        node_process_1.stdout.write('\r');
+        this.renderedLines = 0;
+    }
+    shutdown() {
+        this.clearRenderedBlock();
+        (0, prompt_1.setReplMode)(false);
+        node_process_1.stdin.off('data', this.onDataBound);
+        node_process_1.stdout.off('resize', this.onResizeBound);
+        if (this.resizeTimer)
+            clearTimeout(this.resizeTimer);
+        this.setRawMode(false);
+        node_process_1.stdout.write(`\n  ${ui_1.C.green('Bye.')} ${ui_1.C.dim('See you next time.')}\n\n`);
+        this.resolve(0);
+    }
+    setRawMode(enabled) {
+        if (!node_process_1.stdin.isTTY)
+            return;
+        try {
+            node_process_1.stdin.setRawMode(enabled);
+        }
+        catch {
+            // ignore
+        }
+    }
+}
+function rankPalette(query, item) {
+    const cmd = item.command.toLowerCase();
+    const desc = item.desc.toLowerCase();
+    const cat = item.category.toLowerCase();
+    if (cmd === query)
+        return 0;
+    if (cmd.startsWith(query))
+        return 1;
+    if (cmd.includes(query))
+        return 5;
+    if (cat.startsWith(query))
+        return 10;
+    if (desc.includes(query))
+        return 20;
+    return 50;
+}
+/**
+ * A single ANSI escape sequence, built from the escape byte rather than written
+ * as `\x1b` inside a pattern literal so the rule does not trip
+ * `no-control-regex`.
+ */
+const ESCAPE_SEQUENCE = new RegExp(`^\\u001b\\[[0-9;]*[~A-Za-z]`);
+function splitInput(input) {
+    const out = [];
+    for (let i = 0; i < input.length;) {
+        if (input[i] === '\x1b') {
+            const match = ESCAPE_SEQUENCE.exec(input.slice(i));
+            if (match) {
+                out.push(match[0]);
+                i += match[0].length;
+            }
+            else {
+                out.push('\x1b');
+                i += 1;
+            }
+            continue;
+        }
+        const codePoint = input.codePointAt(i);
+        if (codePoint === undefined)
+            break;
+        const char = String.fromCodePoint(codePoint);
+        out.push(char);
+        i += char.length;
+    }
+    return out;
+}
+async function startInteractive() {
+    const repl = new TerminalRepl();
+    return repl.run();
+}
+//# sourceMappingURL=interactive.js.map