@illuminis/comprism 0.1.0

package/out/commands/ask.js

@@ -0,0 +1,146 @@
+"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.cmdAsk = cmdAsk;
+/**
+ * `comprism ask` — one prompt, one answer, one receipt.
+ *
+ * The shortest complete demonstration of the product: a person types a
+ * question, gets an answer on whichever model finishes it for least, and sees
+ * what that cost against what their own model would have cost.
+ *
+ * NOTHING HERE DECIDES ANYTHING. The prompt goes to our server, the server
+ * chooses the model, runs it, prices both paths and returns the receipt already
+ * worded. This file formats what came back and prints a link. That is the whole
+ * division: a client draws, a server decides.
+ */
+const gateway_1 = require("../lib/gateway");
+const connection_1 = require("../lib/connection");
+const config_1 = require("../lib/config");
+const ui = __importStar(require("../lib/ui"));
+const prompt_1 = require("../lib/prompt");
+const out = (s = '') => process.stdout.write(s + '\n');
+async function cmdAsk(args) {
+    // What they are being compared against, said BEFORE they type. A saving means
+    // nothing without knowing what it is a saving against, and asking a person to
+    // remember what they set last week is asking them to take the figure on
+    // trust. Shown every time, so the number that comes back is never a surprise.
+    const flagged = args.indexOf('--model');
+    const comparedTo = (flagged >= 0 ? args[flagged + 1] : undefined)
+        || (0, config_1.loadConfig)().defaultModel
+        || 'claude-sonnet-5';
+    out(ui.c.dim(`  comparing against ${ui.c.bold(comparedTo)}`)
+        + ui.c.dim('   change it with `comprism model`'));
+    out();
+    // Either way round: on the line for somebody who knows what they want, or
+    // asked for when they simply typed the command.
+    const prompt = await (0, prompt_1.subject)(args, '  prompt: ', ['--model']);
+    if (!prompt) {
+        out(ui.fail('Nothing was asked.'));
+        out();
+        (0, prompt_1.closePrompt)();
+        return;
+    }
+    const conn = (0, connection_1.readConnection)();
+    (0, prompt_1.closePrompt)();
+    if (!conn?.url || !conn.workspaceKey) {
+        out(ui.fail('This machine is not signed in.'));
+        out(`      ${ui.c.dim('$')} comprism login`);
+        out();
+        process.exitCode = 1;
+        return;
+    }
+    // NO KEY IS READ FROM THIS MACHINE.
+    //
+    // This used to scan the shell and the settings file for a vendor key and
+    // forward it with the question. It looks harmless and it is not: a person
+    // whose account holds a key, and who also happens to have one exported in
+    // their shell, would have the work billed to the second account without ever
+    // being told. Two answers to "whose money is this", and the product's whole
+    // claim is a figure on an invoice the customer can check.
+    //
+    // The account's keys are the only keys. They are stored on the workspace,
+    // visible to that person's colleagues, to the portal and to the editor, and
+    // revocable in one place. Owner's rule, 17 September 2026.
+    // The same value shown above. Resolved once, so the line a person read and
+    // the figure they are given can never be about different models.
+    const callingModel = comparedTo;
+    const live = new ui.LiveIndicator();
+    live.start('choosing the model that finishes this for least');
+    const reply = await (0, gateway_1.ask)({
+        intent: 'answer',
+        prompt,
+        callingModel,
+    });
+    live.stop();
+    if (!reply.answer) {
+        out(ui.fail(reply.decision.rationale || 'no answer came back'));
+        out();
+        process.exitCode = 1;
+        return;
+    }
+    out();
+    out(reply.answer.trim());
+    out();
+    if (reply.receipt) {
+        out(ui.c.dim('  ' + reply.receipt.split('\n').join('\n  ')));
+        out();
+    }
+    const money = (n) => n === null || n === undefined ? null : `$${n.toFixed(4)}`;
+    const ran = reply.ran_on || 'your own model';
+    const ours = money(reply.cost_usd);
+    const theirs = money(reply.would_have_cost_usd);
+    const saved = reply.saved_usd;
+    if (ours && theirs) {
+        const verb = saved !== null && saved !== undefined && saved < 0 ? 'more' : 'less';
+        const amount = money(Math.abs(saved ?? 0));
+        out(`  ran on ${ui.c.bold(ran)}  ${ours} to finish`);
+        out(`  ${ui.c.dim(`on ${callingModel} it would have been ${theirs}, so ${amount} ${verb}`)}`);
+    }
+    else {
+        out(`  ran on ${ui.c.bold(ran)}`);
+    }
+    // Said plainly rather than hidden: a figure that rests on a coarse lookup is
+    // still worth showing, and it is never shown as if it were measured.
+    if (reply.estimated) {
+        out(`  ${ui.c.amber('these figures are estimated')}${ui.c.dim(', because this work has no close match in the corpus yet')}`);
+    }
+    if (reply.details_url) {
+        out();
+        out(`  ${ui.c.dim('the full breakdown, every figure traceable:')}`);
+        out(`  ${ui.c.bold(reply.details_url)}`);
+    }
+    out();
+}

package/out/commands/codemap.d.ts

@@ -0,0 +1,2 @@
+export declare const MAP_HELP = "\n  comprism map                   what the map of this project holds\n  comprism map refresh           read every file again, now\n  comprism map forget            remove this project's map from the service\n  comprism map off               ask your administrator to switch it off\n\n  The map is a record of what your project is made of: its functions, screens,\n  endpoints and tables, and what connects to what. It is read on this machine\n  and only its structure is sent. Your source code never leaves here.\n\n  It is kept current by itself. Every job checks the files first and reads back\n  whatever moved, so you should not normally need any of this.\n";
+export declare function cmdMap(args: string[]): Promise<number>;

package/out/commands/codemap.js

@@ -0,0 +1,151 @@
+"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.MAP_HELP = void 0;
+exports.cmdMap = cmdMap;
+/**
+ * `comprism map` — look at the map of this project, refresh it, or switch it
+ * off for one job.
+ *
+ * The map is normally kept current on its own: every job checks the files
+ * before it starts and reads back whatever moved. This command exists for the
+ * two moments that happen anyway. Somebody has just had an answer they did not
+ * believe and wants it rebuilt from scratch. And somebody wants to see what the
+ * product actually holds about their codebase, which is a fair question to ask
+ * of any tool that holds anything.
+ *
+ * Nothing here decides anything. It reads files, sends structure, and prints
+ * what the service says back.
+ */
+const ui = __importStar(require("../lib/ui"));
+const gateway_1 = require("../lib/gateway");
+const sync_1 = require("../graph/sync");
+const settings_1 = require("./settings");
+const out = (s = "") => process.stdout.write(`${s}\n`);
+exports.MAP_HELP = `
+  comprism map                   what the map of this project holds
+  comprism map refresh           read every file again, now
+  comprism map forget            remove this project's map from the service
+  comprism map off               ask your administrator to switch it off
+
+  The map is a record of what your project is made of: its functions, screens,
+  endpoints and tables, and what connects to what. It is read on this machine
+  and only its structure is sent. Your source code never leaves here.
+
+  It is kept current by itself. Every job checks the files first and reads back
+  whatever moved, so you should not normally need any of this.
+`;
+/** The project name the service holds the map under: the folder's own name,
+ *  which is what every other part of the tool sends as the workspace. */
+function projectName(root) {
+    return root.split("/").filter(Boolean).pop() || root;
+}
+async function cmdMap(args) {
+    if (args.includes("--help") || args.includes("-h")) {
+        out(exports.MAP_HELP);
+        return 0;
+    }
+    const root = (0, settings_1.currentWorkspace)().path;
+    const workspace = projectName(root);
+    const action = (args[0] || "status").toLowerCase();
+    if (action === "forget") {
+        const gone = await (0, gateway_1.ask)({
+            intent: "graph", prompt: "", graphOp: "forget", workspace,
+        });
+        if (!gone.ok) {
+            out(ui.fail("The service could not be reached, so nothing was removed."));
+            return 1;
+        }
+        out(ui.ok(`The map of ${workspace} has been removed. The next job will read it again.`));
+        return 0;
+    }
+    if (action === "off") {
+        // Said rather than done. The switch is company-wide and belongs to an
+        // administrator, and a machine credential is not the thing that should be
+        // able to change a control every colleague is subject to. One job can still
+        // go without a map with `comprism work --no-map`.
+        out();
+        out("  The code map is switched on and off for the whole company, under");
+        out("  Administration in the web portal. An administrator can do it there.");
+        out();
+        out("  To run one job without it: comprism work --no-map \"...\"");
+        out();
+        return 0;
+    }
+    if (action === "refresh" || action === "rebuild") {
+        out();
+        out(`  Reading ${workspace}...`);
+        const done = await (0, sync_1.refresh)(root, workspace, { force: true });
+        out();
+        out(done.current ? ui.ok(done.message) : ui.fail(done.message));
+        if (done.unread)
+            out(`  ${ui.c.dim((0, sync_1.readerReport)())}`);
+        out();
+        return done.current ? 0 : 1;
+    }
+    const now = await (0, sync_1.status)(root, workspace);
+    out();
+    if (!now.reachable) {
+        out(ui.fail("The service could not be reached."));
+        out();
+        return 1;
+    }
+    if (!now.enabled) {
+        out("  Your company has the code map switched off. Nothing about your code");
+        out("  is read, sent or stored, and jobs read files the ordinary way.");
+        out();
+        return 0;
+    }
+    if (!now.hasMap) {
+        out(`  There is no map of ${workspace} yet. It will be read the first time`);
+        out("  you run a job here, or now with: comprism map refresh");
+        out();
+        return 0;
+    }
+    const held = now.held ?? {};
+    const counts = (held.counts ?? {});
+    out(`  ${ui.c.bold(workspace)}`);
+    out(`  ${held.files ?? 0} files, read from commit ${String(held.commit ?? "").slice(0, 8) || "none"}`);
+    out(`  ${counts.objects ?? 0} things and ${counts.links ?? 0} links between them`);
+    out(`  ${counts.endpoints ?? 0} endpoints, ${counts.data_models ?? 0} data models, `
+        + `${counts.tables ?? 0} tables, ${counts.screens ?? 0} screens`);
+    out(`  ${now.fresh ? "Matches the files on disk." : "The code has moved since it was read. The next job will bring it up to date."}`);
+    if (held.coverage)
+        out(`  ${ui.c.dim(String(held.coverage))}`);
+    out();
+    out(`  ${ui.c.dim(now.autoRefresh ? "Kept current automatically." : "Only refreshed when you ask.")}`);
+    out();
+    return 0;
+}

package/out/commands/commands-thin.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Sign this machine out.
+ *
+ * ── Forgetting is not signing out ─────────────────────────────────────────
+ *
+ * This used to delete the local copy of the credential and say "disconnected".
+ * The credential stayed live: still listed in the portal, still accepted on
+ * every call, so anybody holding a copy of that file was still signed in and
+ * the person who signed out had no way to know it.
+ *
+ * So the server is told FIRST, on the one service every client shares, and it
+ * revokes the credential where it was minted. The local copy is then removed
+ * whatever the server said, because a person who asked to sign out must not be
+ * left holding a credential on a laptop they have finished with: if the server
+ * could not be reached, the key on this machine is gone and the words say
+ * plainly that it may still be live until it is revoked in the portal.
+ *
+ * `logout`, `signout` and `disconnect` are the same act under the three words
+ * people actually type. `logout` printed "there is no command called logout",
+ * which is the product telling somebody their own vocabulary is wrong.
+ */
+export declare function cmdDisconnect(): Promise<void>;
+/**
+ * Where this machine is pointed, and whether the workspace still accepts it.
+ *
+ * ── Why this asks the server rather than reading the file ─────────────────
+ *
+ * It used to report "signed in" from the presence of a local file, which is a
+ * statement about a laptop and not about an account. A credential revoked in
+ * the portal an hour ago still reads as signed in; so does a machine pointed at
+ * an address that has not answered for a week. That is precisely how a
+ * developer spent an evening on 17 September 2026 believing he was signed in to
+ * a workspace while every call was going to a dead port on his own laptop.
+ *
+ * Status is the command a person runs when something is wrong, so it is the one
+ * command that must never report a local guess as a fact. It asks the one
+ * service and prints what came back, or says it heard nothing.
+ */
+export declare function cmdStatus(): Promise<void>;

package/out/commands/commands-thin.js

@@ -0,0 +1,182 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cmdDisconnect = cmdDisconnect;
+exports.cmdStatus = cmdStatus;
+const node_readline_1 = __importDefault(require("node:readline"));
+const connection_1 = require("../lib/connection");
+const gateway_1 = require("../lib/gateway");
+const ui = __importStar(require("../lib/ui"));
+const out = (s = '') => process.stdout.write(s + '\n');
+function argValue(args, flag) {
+    const i = args.indexOf(flag);
+    return i >= 0 ? args[i + 1] : undefined;
+}
+/**
+ * Read a password without echoing it.
+ *
+ * It never reaches a file, a log or the shell history: the only copy is the
+ * string handed straight to the sign-in call.
+ */
+function askHidden(prompt) {
+    return new Promise((resolve) => {
+        const rl = node_readline_1.default.createInterface({
+            input: process.stdin, output: process.stdout, terminal: true,
+        });
+        const silent = rl;
+        silent._writeToOutput = () => { };
+        process.stdout.write(prompt);
+        rl.question('', (answer) => {
+            rl.close();
+            process.stdout.write('\n');
+            resolve(answer);
+        });
+    });
+}
+// `cmdConnect` lived here and is gone.
+//
+// It was a second sign in: it called the authentication routes and the key
+// route directly, in its own order, and nothing reached it. The published
+// command `connect` has routed to `cmdLogin` for some time, so this was an
+// unreachable copy of the one act the product most needs to have exactly one
+// of. Two sign ins are two places for a rule about who may sign in to be
+// enforced differently, and the dead one is always the one nobody updates.
+/**
+ * Sign this machine out.
+ *
+ * ── Forgetting is not signing out ─────────────────────────────────────────
+ *
+ * This used to delete the local copy of the credential and say "disconnected".
+ * The credential stayed live: still listed in the portal, still accepted on
+ * every call, so anybody holding a copy of that file was still signed in and
+ * the person who signed out had no way to know it.
+ *
+ * So the server is told FIRST, on the one service every client shares, and it
+ * revokes the credential where it was minted. The local copy is then removed
+ * whatever the server said, because a person who asked to sign out must not be
+ * left holding a credential on a laptop they have finished with: if the server
+ * could not be reached, the key on this machine is gone and the words say
+ * plainly that it may still be live until it is revoked in the portal.
+ *
+ * `logout`, `signout` and `disconnect` are the same act under the three words
+ * people actually type. `logout` printed "there is no command called logout",
+ * which is the product telling somebody their own vocabulary is wrong.
+ */
+async function cmdDisconnect() {
+    out(ui.banner('Sign out'));
+    out();
+    const conn = (0, connection_1.readConnection)();
+    if (!conn?.url || !conn.workspaceKey) {
+        (0, connection_1.clearConnection)();
+        out(ui.info('This machine was not signed in.'));
+        out();
+        return;
+    }
+    const reply = await (0, gateway_1.ask)({ intent: 'sign_out', prompt: '' });
+    const removed = (0, connection_1.clearConnection)();
+    if (reply.signed_out) {
+        out(ui.ok(reply.message || 'Signed out. This machine\'s key is revoked.'));
+        out(`      ${ui.c.dim('sign back in with')} ${ui.c.bold('comprism login')}`);
+    }
+    else if (removed) {
+        // Said plainly rather than dressed up. A person who is told "signed out"
+        // when the key is still live has been given the one piece of information
+        // they would have acted on.
+        out(ui.warn('Removed from this machine, but the key could not be revoked.'));
+        out(`      ${ui.c.dim(reply.message
+            || 'the service could not be reached, so revoke this machine in the portal')}`);
+    }
+    else {
+        out(ui.info('This machine was not signed in.'));
+    }
+    out();
+}
+/**
+ * Where this machine is pointed, and whether the workspace still accepts it.
+ *
+ * ── Why this asks the server rather than reading the file ─────────────────
+ *
+ * It used to report "signed in" from the presence of a local file, which is a
+ * statement about a laptop and not about an account. A credential revoked in
+ * the portal an hour ago still reads as signed in; so does a machine pointed at
+ * an address that has not answered for a week. That is precisely how a
+ * developer spent an evening on 17 September 2026 believing he was signed in to
+ * a workspace while every call was going to a dead port on his own laptop.
+ *
+ * Status is the command a person runs when something is wrong, so it is the one
+ * command that must never report a local guess as a fact. It asks the one
+ * service and prints what came back, or says it heard nothing.
+ */
+async function cmdStatus() {
+    const c = (0, connection_1.readConnection)();
+    out(ui.banner('Status'));
+    out();
+    if (!c?.url) {
+        out(ui.warn('Not signed in.'));
+        out(`      ${ui.c.dim('$')} comprism login`);
+        out();
+        return;
+    }
+    const reply = await (0, gateway_1.ask)({ intent: 'session', prompt: '' });
+    const me = reply.ok && reply.served !== false ? reply.session : null;
+    if (!reply.ok) {
+        out(ui.fail(`This machine is pointed at ${ui.c.bold(c.url)}, which did not answer.`));
+        out(`      ${ui.c.dim(reply.message || 'no answer from the workspace')}`);
+        out(`      ${ui.c.dim('sign in again with')} ${ui.c.bold('comprism login')}`);
+        out();
+        process.exitCode = 1;
+        return;
+    }
+    if (!me) {
+        // It answered, but this build does not carry the question. Say that, rather
+        // than pretending to know or pretending not to have heard.
+        out(ui.warn(`${ui.c.bold(c.url)} answered, but is running a build that cannot report a session.`));
+        out(`      ${ui.c.dim(reply.message || 'the workspace is behind this copy of the tool')}`);
+        out();
+        return;
+    }
+    out(ui.ok(`Signed in to ${ui.c.bold(me.workspace_url || c.url)}`));
+    out(`      ${ui.c.dim('as')} ${me.user_email}${ui.c.dim(' at ')}${me.company}`);
+    out(`      ${ui.c.dim(me.machine ? `this machine is enrolled as "${me.machine}"` : 'this machine is enrolled')}`);
+    out(`      ${ui.c.dim(me.vendors_known === false
+        ? 'your vendor keys could not be checked, so that is unknown rather than none'
+        : `${me.vendors_with_key} vendor key${me.vendors_with_key === 1 ? '' : 's'} stored on your account`)}`);
+    out();
+    out(ui.c.dim('  Every figure you see is computed on our servers, never here.'));
+    out();
+}