@illuminis/comprism 0.1.3 → 0.1.4

package/out/lib/history.js

@@ -0,0 +1,137 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.History = void 0;
+exports.historyFile = historyFile;
+/**
+ * Earlier requests, for Up, Down and Ctrl+R (manual 6.5).
+ *
+ * Always kept in memory for the session. Kept on this machine between sessions
+ * only when the service says the company lets prompt text be kept, and then in
+ * one file, `history` in the tool's own folder, readable by this account only.
+ * When the company does not, the file is removed at the start and at the end of
+ * the session, so a rule changed by an administrator is honored by the next
+ * session without anybody deleting anything by hand.
+ *
+ * The decision is the service's (`commands` intent, `keep_history`). This file
+ * only does what it was told.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const config_1 = require("./config");
+const keyboard_1 = require("./keyboard");
+/** How many requests are remembered. */
+const MAX_ENTRIES = 500;
+/** A request longer than this is remembered for the session only. A 1,000
+ *  line paste is not something to replay from a file next week. */
+const MAX_SAVED_CHARS = 4000;
+function historyFile() {
+    return path.join((0, config_1.homeDir)(), 'history');
+}
+class History {
+    /** Newest first, as shown on the prompt line. Shared with the reader, which
+     *  walks it with Up and Down. */
+    entries = [];
+    /** Newest first, as sent. What the file holds. */
+    saved = [];
+    /** The company's rule: true keeps, false removes, null (the service could
+     *  not be asked) keeps this session's requests in memory and leaves any
+     *  file exactly as it is. */
+    keep = null;
+    /** Begin a session under the company's rule. */
+    start(keep) {
+        this.keep = keep;
+        if (keep === false)
+            this.remove();
+        if (keep !== true)
+            return;
+        try {
+            const lines = fs.readFileSync(historyFile(), 'utf8').split('\n').filter(Boolean);
+            for (const line of lines) {
+                try {
+                    const text = JSON.parse(line);
+                    if (typeof text === 'string')
+                        this.saved.push(text);
+                }
+                catch { /* a damaged line is skipped, not fatal */ }
+            }
+        }
+        catch { /* no file yet */ }
+        this.saved = this.saved.slice(0, MAX_ENTRIES);
+        this.entries.splice(0, this.entries.length, ...this.saved.map(keyboard_1.asOneLine));
+    }
+    off = false;
+    /** `history off`: nothing is remembered, in memory or on disk. */
+    disable() {
+        this.off = true;
+        this.entries.splice(0);
+    }
+    /** Remember one request. `shown` is how it looked at the prompt, paste
+     *  labels included; `sent` is what was sent. */
+    add(shown, sent) {
+        const line = (0, keyboard_1.asOneLine)(shown).trim();
+        if (!line || this.off)
+            return;
+        const at = this.entries.indexOf(line);
+        if (at !== -1)
+            this.entries.splice(at, 1);
+        this.entries.unshift(line);
+        this.entries.splice(MAX_ENTRIES);
+        if (this.keep !== true || sent.length > MAX_SAVED_CHARS)
+            return;
+        this.saved = [sent, ...this.saved.filter((s) => s !== sent)].slice(0, MAX_ENTRIES);
+        this.write();
+    }
+    /** End the session. Without permission to keep, nothing is left behind. */
+    finish() {
+        if (this.keep === false)
+            this.remove();
+    }
+    write() {
+        try {
+            fs.mkdirSync((0, config_1.homeDir)(), { recursive: true, mode: 0o700 });
+            const body = this.saved.map((s) => JSON.stringify(s)).join('\n') + '\n';
+            fs.writeFileSync(historyFile(), body, { mode: 0o600 });
+        }
+        catch { /* a history that could not be written costs typing, nothing more */ }
+    }
+    remove() {
+        try {
+            fs.rmSync(historyFile(), { force: true });
+        }
+        catch { /* already gone */ }
+    }
+}
+exports.History = History;

package/out/lib/ide.d.ts

@@ -0,0 +1,19 @@
+export interface EditorLink {
+    folder: string;
+    context(): Promise<{
+        file?: string;
+        selection?: {
+            text: string;
+            from: number;
+            to: number;
+        };
+        problems?: string[];
+    } | null>;
+    diff(name: string, input: Record<string, unknown>): Promise<void>;
+    open(file: string, line?: number): Promise<void>;
+}
+export declare function lockFolder(): string;
+/** The VS Code window whose folder holds `root`, if one is running. */
+export declare function findEditor(root: string): EditorLink | null;
+/** The selected lines, as the panel sends them (VS Code manual 3.3). */
+export declare function selectionText(ctx: Awaited<ReturnType<EditorLink["context"]>>): string;

package/out/lib/ide.js

@@ -0,0 +1,131 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lockFolder = lockFolder;
+exports.findEditor = findEditor;
+exports.selectionText = selectionText;
+/**
+ * The terminal tool, joined to a VS Code window (VS Code manual 9.12).
+ *
+ * When the CompletionPrism extension is running it leaves a small file in
+ * `~/.completionprism/ide/` naming a port on this machine and a secret. This
+ * finds the file for the folder the job is in, and asks that window three
+ * things: what is open and selected, to show a proposed change in its diff
+ * view, and to open a file at a line.
+ *
+ * It is CompletionPrism's own connection: its own folder, its own secret, only
+ * this user's files. It never looks for, or speaks to, another tool's editor
+ * connection.
+ */
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+function alive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function lockFolder() {
+    return path.join(os.homedir(), ".completionprism", "ide");
+}
+/** The VS Code window whose folder holds `root`, if one is running. */
+function findEditor(root) {
+    let names = [];
+    try {
+        names = fs.readdirSync(lockFolder()).filter((n) => n.endsWith(".json"));
+    }
+    catch {
+        return null;
+    }
+    const here = path.resolve(root);
+    for (const name of names) {
+        let lock;
+        try {
+            lock = JSON.parse(fs.readFileSync(path.join(lockFolder(), name), "utf8"));
+        }
+        catch {
+            continue;
+        }
+        if (!lock.port || !lock.token || !alive(lock.pid))
+            continue;
+        const folder = lock.folders.find((f) => here === f || here.startsWith(f + path.sep));
+        if (!folder)
+            continue;
+        const call = async (what, body) => {
+            const res = await fetch(`http://127.0.0.1:${lock.port}/${what}`, {
+                method: "POST",
+                headers: { "content-type": "application/json", "x-completionprism-token": lock.token },
+                body: JSON.stringify(body),
+                signal: AbortSignal.timeout(2000),
+            });
+            return res.ok ? res.json() : null;
+        };
+        return {
+            folder,
+            context: async () => {
+                try {
+                    return (await call("context", {}));
+                }
+                catch {
+                    return null;
+                }
+            },
+            diff: async (tool, input) => {
+                try {
+                    await call("diff", { name: tool, input, root: here });
+                }
+                catch { /* the terminal still shows it */ }
+            },
+            open: async (file, line) => {
+                try {
+                    await call("open", { path: file, line, root: here });
+                }
+                catch { /* nothing to open it in */ }
+            },
+        };
+    }
+    return null;
+}
+/** The selected lines, as the panel sends them (VS Code manual 3.3). */
+function selectionText(ctx) {
+    if (!ctx?.selection?.text || !ctx.file)
+        return "";
+    const { from, to, text } = ctx.selection;
+    return `\n\nSelected lines ${from} to ${to} of ${ctx.file}:\n\`\`\`\n${text}\n\`\`\``;
+}

package/out/lib/keyboard.d.ts

@@ -0,0 +1,95 @@
+/**
+ * The keystrokes a session's reader never sees on their own (manual 6.2, 6.3,
+ * 6.5).
+ *
+ * Node's line reader edits one line well and knows nothing about a paste: every
+ * line break inside a pasted stack trace reached it as Enter, so a 240 line
+ * paste was sent as 240 requests, each billed. It also has no Alt+Enter and no
+ * search of earlier requests.
+ *
+ * So the session's reader reads from this filter instead of from the keyboard.
+ * The filter passes ordinary typing straight through and handles four things
+ * itself:
+ *
+ * * A paste, bracketed by the terminal, becomes one piece of the request. The
+ *   reader is given a short label, `[pasted 240 lines]`, that can be edited
+ *   around like any word, and the label is swapped back for the exact text,
+ *   tabs and trailing spaces included, when the request is sent.
+ * * A terminal that does not bracket pastes still delivers a paste in one read,
+ *   so several lines arriving in one read are treated the same way. A person
+ *   typing never produces a line break followed by more text in one read.
+ * * Alt+Enter continues the request on a new line, exactly as `\` then Enter.
+ * * Ctrl+R searches earlier requests; Enter puts the match at the prompt to be
+ *   edited or sent, and Esc or Ctrl+C puts back what was there.
+ *
+ * Nothing here is written anywhere. Pieces live in memory for the session.
+ */
+import { PassThrough } from 'node:stream';
+import type readline from 'node:readline';
+/** Stands for a line break inside a request shown on one line, such as a
+ *  recalled request. Turned back into a line break when it is sent. */
+export declare const LINE_BREAK = "\u2424";
+/** A request as it is shown on one editable line. */
+export declare function asOneLine(text: string): string;
+export declare class Keyboard {
+    private readonly history;
+    /** What the session's reader reads. */
+    readonly input: PassThrough;
+    private readonly decoder;
+    private pieces;
+    private pasting;
+    private carry;
+    private continued;
+    private search;
+    private reader;
+    private listening;
+    private readonly onData;
+    /** Esc on its own (manual 6.7). Returns true when it was used, so the key
+     *  goes no further; false passes it to the reader as before. */
+    onEscape: (() => boolean) | null;
+    /** Ctrl+O, the short or full view (manual 6.9). */
+    onFullView: (() => void) | null;
+    /** Ctrl+G, the request in your own editor (manual 6.6). */
+    onEditor: (() => void) | null;
+    /** Ctrl+V, the clipboard's picture, where the terminal passes it (3.4). */
+    onPasteImage: (() => void) | null;
+    /** `keys vi` (manual 6.10): Esc at the prompt enters normal mode. */
+    vi: boolean;
+    private normal;
+    private pendingD;
+    /** `history` is the session's earlier requests, newest first, as shown. */
+    constructor(history: () => string[]);
+    /** The reader whose line a search edits. */
+    bind(reader: readline.Interface | null): void;
+    /**
+     * Start reading the keyboard. Raw, because the reader no longer holds the
+     * keyboard itself and so cannot switch it; bracketed, so the terminal marks
+     * where a paste begins and ends.
+     */
+    attach(): void;
+    /**
+     * Stop reading, and give the keyboard back exactly as it was found, for a
+     * command that asks its own question and for the shell afterwards. A shell
+     * left with bracketed paste on prints markers around everything pasted.
+     */
+    detach(): void;
+    /** True once after Alt+Enter, so the line just ended continues the request. */
+    takeContinued(): boolean;
+    /** The request as it will be sent: every paste label swapped for its text,
+     *  and every shown line break made a real one again. */
+    expand(text: string): string;
+    /** Feed raw keyboard text. Public so a test can type without a terminal. */
+    take(s: string): void;
+    private forward;
+    /** Typing, outside a bracketed paste. */
+    private keys;
+    private paste;
+    private viKeys;
+    private editable;
+    private startSearch;
+    private match;
+    private drawSearch;
+    private setLine;
+    private endSearch;
+    private searchKeys;
+}