@illuminis/comprism 0.1.2 → 0.1.4

package/out/commands/instructions.js

@@ -0,0 +1,113 @@
+"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.cmdInstructions = cmdInstructions;
+/**
+ * `comprism instructions` (manual 2.5 to 2.8): every instruction source the
+ * next job receives, and editing your personal ones. The list is the service's
+ * own, from the same function the job uses.
+ */
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const project_ops_1 = require("../lib/project-ops");
+const ui = __importStar(require("../lib/ui"));
+const out = (s = "") => process.stdout.write(s + "\n");
+/** Subfolders holding an instruction file, found by looking, not guessing. */
+function subfolders(root, w) {
+    const found = {};
+    const skip = new Set(w.skip);
+    const queue = [["", 0]];
+    while (queue.length && Object.keys(found).length < w.max_subfolders) {
+        const [rel, depth] = queue.shift();
+        let entries;
+        try {
+            entries = fs.readdirSync(path.join(root, rel), { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const e of entries) {
+            if (!e.isDirectory() || e.name.startsWith(".") || skip.has(e.name))
+                continue;
+            const child = rel ? `${rel}/${e.name}` : e.name;
+            for (const name of w.subfolder_files) {
+                const body = (0, project_ops_1.readInside)(root, `${child}/${name}`);
+                if (body !== undefined && body.trim()) {
+                    found[`${child}/${name}`] = body;
+                    break;
+                }
+            }
+            if (depth + 1 < w.max_depth)
+                queue.push([child, depth + 1]);
+        }
+    }
+    return found;
+}
+async function cmdInstructions(args) {
+    const facts = await (0, project_ops_1.currentProject)();
+    if (args[0] === "edit") {
+        if (!args.includes("--personal")) {
+            out(ui.fail("Project instructions are files in the project; edit them there. "
+                + "For yours: comprism instructions edit --personal"));
+            return 2;
+        }
+        const now = await (0, project_ops_1.call)("instructions", "get_personal", {}, facts, true);
+        if (!now)
+            return 1;
+        const file = path.join(fs.mkdtempSync(path.join(os.tmpdir(), "comprism-")), "personal-instructions.md");
+        fs.writeFileSync(file, String(now.data?.text ?? ""));
+        const closed = await (0, project_ops_1.openEditor)([file]);
+        const text = fs.readFileSync(file, "utf8");
+        fs.rmSync(path.dirname(file), { recursive: true, force: true });
+        if (!closed) {
+            out(ui.fail("The editor did not close cleanly, so nothing was saved."));
+            return 1;
+        }
+        out();
+        return (await (0, project_ops_1.call)("instructions", "set_personal", { text }, facts)) ? 0 : 1;
+    }
+    const wanted = await (0, project_ops_1.call)("instructions", "wanted", {}, facts, true);
+    if (!wanted)
+        return 1;
+    const w = wanted.data;
+    const inSub = subfolders(facts.root, w);
+    const files = { ...(0, project_ops_1.readSome)(facts.root, w.root_files), ...inSub };
+    const folders = Object.keys(inSub).map((f) => f.slice(0, f.lastIndexOf("/")));
+    out();
+    const reply = await (0, project_ops_1.call)("instructions", "list", { files, subfolders: folders }, facts);
+    out();
+    return reply ? 0 : 1;
+}

package/out/commands/integrations.d.ts

@@ -0,0 +1,3 @@
+export declare const INTEGRATIONS_HELP = "  comprism integrations                              what is connected here\n  comprism integrations add <name> --url <address>   a tool server on the internet\n  comprism integrations add <name> --command \"<cmd>\" a tool server on this machine\n      --scope project|personal|company               who gets it (personal by default)\n  comprism integrations login <name>                 sign in to it\n  comprism integrations tools <name>                 its tools\n  comprism integrations remove <name> [--scope ...]  remove it";
+export declare function cmdIntegrations(args: string[]): Promise<number>;
+export declare function projectSettings(root: string): Record<string, unknown>;

package/out/commands/integrations.js

@@ -0,0 +1,215 @@
+"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.INTEGRATIONS_HELP = void 0;
+exports.cmdIntegrations = cmdIntegrations;
+exports.projectSettings = projectSettings;
+/**
+ * `comprism integrations` (manual 9.10 to 9.14, 9.18): the connections here,
+ * adding one by address or by command, signing in, its tools, removing one.
+ *
+ * The service decides every status, tool, rule and word. This sends the
+ * project's settings file so the project's own connections are known, writes
+ * the key the service returns for a project connection, starts an approved
+ * local tool server only long enough to count its tools, opens the browser
+ * for a sign in and waits for it. No token ever reaches this machine.
+ */
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const toolservers_1 = require("../executor/toolservers");
+const gateway_1 = require("../lib/gateway");
+const project_ops_1 = require("../lib/project-ops");
+const project_1 = require("../lib/project");
+const ui = __importStar(require("../lib/ui"));
+const SETTINGS = ".completionprism/settings.json";
+const out = (s = "") => process.stdout.write(`${s}\n`);
+function flag(args, name) {
+    const at = args.indexOf(name);
+    return at >= 0 ? args[at + 1] : undefined;
+}
+async function call(root, payload) {
+    const base = { project: root, settings: (0, project_ops_1.readInside)(root, SETTINGS) ?? null };
+    let reply = await (0, gateway_1.ask)({ intent: "integrations", prompt: "", integrationsPayload: { ...base, ...payload } });
+    let body = reply.integrations;
+    // Local servers are counted on this machine, then the answer is asked again.
+    if (reply.ok && body?.probe) {
+        const servers = new toolservers_1.ToolServers(root);
+        const local_results = {};
+        for (const p of body.probe) {
+            const r = await servers.list(p.name, p.command);
+            local_results[p.name] = r.isError ? { error: r.content } : JSON.parse(r.content);
+        }
+        servers.stopAll();
+        reply = await (0, gateway_1.ask)({ intent: "integrations", prompt: "", integrationsPayload: { ...base, ...payload, local_results } });
+        body = reply.integrations;
+    }
+    if (!reply.ok || reply.served === false || !body) {
+        out(`  ${ui.fail(reply.message || "Your connections could not be read from your workspace.")}`);
+        return null;
+    }
+    if (body.error) {
+        out(`  ${ui.fail(body.error)}`);
+        return null;
+    }
+    return body;
+}
+function draw(rows) {
+    const w = (k) => Math.max(...rows.map((r) => k(r).length)) + 3;
+    const nw = w((r) => r.name), kw = w((r) => r.kind), sw = w((r) => r.status);
+    for (const r of rows) {
+        const tools = `${r.tools} tool${r.tools === 1 ? "" : "s"}`;
+        const line = `${r.name.padEnd(nw)}${r.kind.padEnd(kw)}${r.status.padEnd(sw)}${tools.padEnd(11)}${r.where}`;
+        out(`  ${r.status === "connected" ? line : ui.c.dim(line)}${r.note ? ui.c.dim(`   ${r.note}`) : ""}`);
+    }
+}
+function openBrowser(url) {
+    if (process.env.COMPRISM_NO_BROWSER === "1")
+        return;
+    const [cmd, args] = process.platform === "darwin" ? ["open", [url]]
+        : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
+    try {
+        // nosemgrep: javascript.lang.security.detect-child-process.detect-child-process -- opens a sign in address in the browser, passed as one argument, never through a shell
+        (0, child_process_1.spawn)(cmd, args, { stdio: "ignore", detached: true }).unref();
+    }
+    catch { /* the address is printed as well */ }
+}
+async function login(root, name) {
+    const started = await call(root, { op: "login", name });
+    if (!started?.authorize_url)
+        return 1;
+    out(`  ${started.line ?? ""}`);
+    out(ui.c.dim(`  If it did not open: ${started.authorize_url}`));
+    openBrowser(started.authorize_url);
+    const waitMs = Number(process.env.COMPRISM_SIGN_IN_WAIT_MS || 180_000);
+    const until = Date.now() + waitMs;
+    while (Date.now() < until) {
+        await new Promise((r) => setTimeout(r, 2000));
+        const now = await call(root, { op: "status", name });
+        if (!now)
+            return 1;
+        if (now.row && now.row.status !== "needs sign in") {
+            out(`  ${name} is ${now.row.status}${now.row.tools ? `, ${now.row.tools} tools` : ""}.`);
+            return now.row.status === "connected" ? 0 : 1;
+        }
+    }
+    out(`  ${ui.fail(`Sign in was not completed, so ${name} still needs sign in. Run comprism integrations login ${name} to try again.`)}`);
+    return 1;
+}
+exports.INTEGRATIONS_HELP = `  comprism integrations                              what is connected here
+  comprism integrations add <name> --url <address>   a tool server on the internet
+  comprism integrations add <name> --command "<cmd>" a tool server on this machine
+      --scope project|personal|company               who gets it (personal by default)
+  comprism integrations login <name>                 sign in to it
+  comprism integrations tools <name>                 its tools
+  comprism integrations remove <name> [--scope ...]  remove it`;
+async function cmdIntegrations(args) {
+    if (args.includes("--help") || args.includes("-h")) {
+        out(exports.INTEGRATIONS_HELP);
+        return 0;
+    }
+    const valued = new Set(["--url", "--command", "--scope", "--cwd"]);
+    const words = args.filter((a, i) => !a.startsWith("--") && !valued.has(args[i - 1] ?? ""));
+    const [sub, name] = words;
+    const root = (0, project_1.resolveProject)(flag(args, "--cwd") ?? process.cwd()).root;
+    const scope = flag(args, "--scope");
+    if (!sub) {
+        const body = await call(root, { op: "list" });
+        if (!body)
+            return 1;
+        if (!body.rows?.length)
+            out(`  ${body.empty ?? ""}`);
+        else
+            draw(body.rows);
+        return 0;
+    }
+    if (!name && ["add", "login", "tools", "remove"].includes(sub)) {
+        out(`  ${ui.fail(`comprism integrations ${sub} takes the connection's name.`)}`);
+        return 2;
+    }
+    switch (sub) {
+        case "add": {
+            const body = await call(root, { op: "add", name, url: flag(args, "--url"), command: flag(args, "--command"), scope });
+            if (!body)
+                return 1;
+            if (body.write) {
+                (0, project_ops_1.writeSetting)(root, body.write.file, body.write.key, body.write.value);
+            }
+            out(`  ${body.line ?? ""}`);
+            // If the server needs a sign in, the browser opens now (9.11).
+            if (body.needs_sign_in)
+                return login(root, String(name));
+            return 0;
+        }
+        case "login":
+            return login(root, String(name));
+        case "tools": {
+            const body = await call(root, { op: "tools", name });
+            if (!body)
+                return 1;
+            if (body.line)
+                out(`  ${body.line}`);
+            const tools = body.tools ?? [];
+            const w = Math.max(0, ...tools.map((t) => t.name.length)) + 3;
+            for (const t of tools) {
+                const kind = t.blocked ? "blocked" : t.reads ? "reads" : "changes";
+                out(`  ${t.name.padEnd(w)}${kind.padEnd(9)}${ui.c.dim(t.description)}`);
+            }
+            return 0;
+        }
+        case "remove": {
+            const body = await call(root, { op: "remove", name, scope });
+            if (!body)
+                return 1;
+            if (body.write)
+                (0, project_ops_1.writeSetting)(root, body.write.file, body.write.key, body.write.value);
+            out(`  ${body.line ?? ""}`);
+            return 0;
+        }
+        default:
+            out(`  ${ui.fail(`\`integrations ${sub}\` is not an integrations command.`)}`);
+            out(exports.INTEGRATIONS_HELP);
+            return 2;
+    }
+}
+// Kept for tests that read the settings file the service told us to write.
+function projectSettings(root) {
+    try {
+        return JSON.parse(fs.readFileSync(path.join(root, SETTINGS), "utf8"));
+    }
+    catch {
+        return {};
+    }
+}

package/out/commands/jobs.d.ts

@@ -0,0 +1,5 @@
+/** Where a background job's log is noted, by job id, on this machine. */
+export declare function pointerFor(jobId: string): string;
+/** Written by the background process once it knows its job id. */
+export declare function notePointer(jobId: string, log: string): void;
+export declare function cmdJobs(args: string[]): Promise<number>;

package/out/commands/jobs.js

@@ -0,0 +1,157 @@
+"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.pointerFor = pointerFor;
+exports.notePointer = notePointer;
+exports.cmdJobs = cmdJobs;
+/**
+ * `comprism jobs`, `jobs attach`, `jobs stop` (manual 5.14).
+ *
+ * The list and the stopping are the service's: it knows which of this
+ * person's jobs run in the background and it stops them. Attaching is local,
+ * because a background job's output is written to a log on this machine by the
+ * process doing the work, and watching it means reading that file as it grows.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("../lib/config");
+const gateway_1 = require("../lib/gateway");
+const ui = __importStar(require("../lib/ui"));
+const out = (s = "") => process.stdout.write(`${s}\n`);
+/** Where a background job's log is noted, by job id, on this machine. */
+function pointerFor(jobId) {
+    return path.join((0, config_1.homeDir)(), "jobs", `${jobId}.json`);
+}
+/** Written by the background process once it knows its job id. */
+function notePointer(jobId, log) {
+    try {
+        fs.mkdirSync(path.join((0, config_1.homeDir)(), "jobs"), { recursive: true });
+        fs.writeFileSync(pointerFor(jobId), JSON.stringify({ log, pid: process.pid }), { mode: 0o600 });
+    }
+    catch { /* attaching is a convenience; the job runs regardless */ }
+}
+async function ask(op, job) {
+    return (0, gateway_1.ask)({ intent: "jobs", prompt: "", jobsPayload: { op, ...(job ? { job } : {}) } });
+}
+function alive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function cmdJobs(args) {
+    const [op, name] = [args[0], args[1]];
+    if (!op || op === "list") {
+        const r = await ask("list");
+        if (!r.ok || !r.jobs) {
+            out(ui.fail(r.message || "The job list could not be read."));
+            return 1;
+        }
+        for (const line of r.jobs.lines)
+            out(`  ${line}`);
+        return 0;
+    }
+    if ((op === "attach" || op === "stop") && !name) {
+        out(ui.fail(`jobs ${op} needs a job, for example jobs ${op} j_7c21.`));
+        return 2;
+    }
+    if (op === "stop") {
+        const r = await ask("stop", name);
+        if (!r.ok || !r.jobs) {
+            out(ui.fail(r.message || "That job could not be stopped."));
+            return 1;
+        }
+        for (const line of r.jobs.lines)
+            out(`  ${line}`);
+        return 0;
+    }
+    if (op === "attach") {
+        const r = await ask("find", name);
+        if (!r.ok || !r.jobs?.job_id) {
+            out(ui.fail(r.message || "There is no such job."));
+            return 1;
+        }
+        let note;
+        try {
+            note = JSON.parse(fs.readFileSync(pointerFor(r.jobs.job_id), "utf8"));
+        }
+        catch {
+            out(ui.fail("That job did not start on this machine, so its output is not here. The portal's Work page shows it."));
+            return 1;
+        }
+        return follow(note.log, note.pid);
+    }
+    out(ui.fail(`jobs has no ${op}. Use jobs, jobs attach <job> or jobs stop <job>.`));
+    return 2;
+}
+/** Print the log and keep printing as it grows, until the job's process ends
+ *  or Ctrl+C. Ctrl+C here stops watching, never the job. */
+function follow(log, pid) {
+    return new Promise((resolve) => {
+        let at = 0;
+        const pump = () => {
+            try {
+                const size = fs.statSync(log).size;
+                if (size > at) {
+                    const fd = fs.openSync(log, "r");
+                    const buf = Buffer.alloc(size - at);
+                    fs.readSync(fd, buf, 0, buf.length, at);
+                    fs.closeSync(fd);
+                    at = size;
+                    process.stdout.write(buf.toString());
+                }
+            }
+            catch { /* not written yet */ }
+        };
+        const timer = setInterval(() => {
+            pump();
+            if (!alive(pid)) {
+                clearInterval(timer);
+                pump();
+                out(ui.c.dim("  the job has finished"));
+                resolve(0);
+            }
+        }, 300);
+        process.once("SIGINT", () => {
+            clearInterval(timer);
+            out(ui.c.dim("\n  stopped watching; the job carries on. jobs stop stops it."));
+            resolve(0);
+        });
+        pump();
+    });
+}