@illuminis/comprism 0.1.5 → 0.1.7

package/out/machine/runtime/self.js

@@ -0,0 +1,124 @@
+"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.isStandalone = isStandalone;
+exports.standaloneBinDir = standaloneBinDir;
+exports.installMethod = installMethod;
+exports.selfLaunch = selfLaunch;
+exports.shippedFile = shippedFile;
+/**
+ * How this copy of the tool was installed, and how it starts another copy of
+ * itself (manual 1.1).
+ *
+ * The same code ships two ways. Through npm it is a script that Node runs, so
+ * `process.argv[1]` is the script and a second copy is `node <script> <args>`.
+ * Through the install script and the Python package it is one ready to run
+ * program with Node built in, where `process.argv[1]` is the program again and
+ * a second copy is just `<program> <args>`. Passing the program's own path as
+ * the first argument there would read as a command called "/Users/me/...", so
+ * every place that starts a copy of the tool asks here instead of guessing.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const home_1 = require("./home");
+let sea;
+/** True when running as the ready to run program rather than under Node. */
+function isStandalone() {
+    if (sea === undefined) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            sea = Boolean(require("node:sea").isSea());
+        }
+        catch {
+            sea = false;
+        }
+    }
+    return sea;
+}
+/** Where the install script keeps the program: `~/.comprism/bin`. */
+function standaloneBinDir() {
+    return path.join((0, home_1.homeDir)(), "bin");
+}
+/**
+ * Which of the three install options put this copy here.
+ *
+ * The program is only ever distributed two ways, so where it sits decides it:
+ * in `~/.comprism/bin` it came from the install script, anywhere else pip put
+ * it. Under Node it came from npm.
+ */
+function installMethod() {
+    if (!isStandalone())
+        return "npm";
+    try {
+        const here = fs.realpathSync(process.execPath);
+        const bin = fs.realpathSync(standaloneBinDir());
+        if (path.dirname(here) === bin)
+            return "script";
+    }
+    catch {
+        // No `~/.comprism/bin`: not an install script install.
+    }
+    return "python";
+}
+/** The command and arguments that start another copy of this tool. */
+function selfLaunch(args, nodeFlags = []) {
+    if (isStandalone())
+        return [process.execPath, args];
+    return [process.execPath, [...nodeFlags, process.argv[1] ?? "", ...args]];
+}
+/**
+ * A file shipped beside the code, as a path on disk.
+ *
+ * Under npm it sits in the package. Inside the program it is carried as an
+ * asset and written once to `~/.comprism/assets`, because the programs it is
+ * handed to (Python, for the reader script) need a real file.
+ */
+function shippedFile(name, packagePath) {
+    if (!isStandalone())
+        return packagePath;
+    const target = path.join((0, home_1.homeDir)(), "assets", name);
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const text = require("node:sea").getAsset(name, "utf8");
+        if (!fs.existsSync(target) || fs.readFileSync(target, "utf8") !== text) {
+            fs.mkdirSync(path.dirname(target), { recursive: true });
+            fs.writeFileSync(target, text);
+        }
+    }
+    catch {
+        // An asset that cannot be written leaves the caller's own fallback in charge.
+    }
+    return target;
+}

package/out/machine/voice/record.d.ts

@@ -0,0 +1,38 @@
+/** One recording tool, as this file needs to drive it. */
+export interface Recorder {
+    /** What to tell somebody who wants to know what is listening. */
+    name: string;
+    command: string;
+    args: (out: string) => string[];
+}
+/** The first recording tool this machine has, or null. */
+export declare function recorder(): Recorder | null;
+/**
+ * What to tell somebody who has no recording tool, or null when they do.
+ *
+ * One sentence and one command. Not a list of three options with trade-offs:
+ * somebody who just wanted to say a sentence out loud is not shopping for audio
+ * software.
+ */
+export declare function missing(): string | null;
+/** A recording in progress. */
+export interface Recording {
+    /** Where the audio is being written. */
+    file: string;
+    /** What is doing the listening, for the line on screen. */
+    by: string;
+    /** Stop, wait for the file to be finished properly, and hand it back. */
+    stop: () => Promise<{
+        file: string;
+        bytes: number;
+    }>;
+}
+/**
+ * Start listening.
+ *
+ * Throws when there is nothing to listen with, which the caller should have
+ * headed off with `missing` so the person gets a sentence rather than an error.
+ */
+export declare function start(): Recording;
+/** Delete the recording and the folder holding it. Always, and immediately. */
+export declare function discard(file: string): void;

package/out/machine/voice/record.js

@@ -0,0 +1,208 @@
+"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.recorder = recorder;
+exports.missing = missing;
+exports.start = start;
+exports.discard = discard;
+/**
+ * Recording what a person says, on their own computer, for every client that
+ * offers a microphone: the command line and the editor extension.
+ *
+ * Physical work on the person's machine, so it lives here once rather than in
+ * each client (rule 17). Nothing here transcribes: the recording goes to our
+ * server, which asks a vendor, and the words come back. See the terminal's
+ * `lib/voice.ts` and the service's `transcription.py`.
+ *
+ * ── Recording without adding a dependency ─────────────────────────────────
+ *
+ * This drives a recording tool the machine already has rather than a compiled
+ * microphone library on every customer's laptop. macOS ships no command line
+ * recorder, so on a Mac with neither ffmpeg nor sox this does not work, and
+ * `missing` says so in one sentence naming the one command that fixes it.
+ *
+ * ── Stopping ──────────────────────────────────────────────────────────────
+ *
+ * Every one of these tools writes a WAV header that is only correct once the
+ * recording ends properly, so stopping means an interrupt and then WAITING for
+ * the tool to finish writing. Killing it outright leaves a file whose header
+ * claims a length it does not have, which every transcriber reads as silence.
+ */
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+/** Is this on the PATH at all. */
+function present(command) {
+    try {
+        return (0, node_child_process_1.spawnSync)('which', [command], { stdio: 'ignore' }).status === 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Sixteen kilohertz, one channel, everywhere.
+ *
+ * What every speech model wants and nothing more. Recording in studio quality
+ * would make a file several times the size, take longer to upload, and be
+ * downsampled by the vendor on arrival anyway.
+ */
+const RATE = '16000';
+const RECORDERS = [
+    // sox first. It is the one built for this, it needs no device name, and it
+    // stops cleanly.
+    { name: 'sox', command: 'rec', args: (out) => ['-q', '-c', '1', '-r', RATE, out] },
+    {
+        name: 'ffmpeg',
+        command: 'ffmpeg',
+        args: (out) => [
+            '-loglevel', 'quiet', '-nostdin',
+            ...(process.platform === 'darwin'
+                ? ['-f', 'avfoundation', '-i', ':default']
+                : ['-f', 'alsa', '-i', 'default']),
+            // Written as it is heard, not held until the end, so the meter and the
+            // words so far have something to read while the person is speaking.
+            '-ac', '1', '-ar', RATE, '-flush_packets', '1', '-y', out,
+        ],
+    },
+    // Linux's own, present on most desktop installs.
+    { name: 'arecord', command: 'arecord', args: (out) => ['-q', '-f', 'S16_LE', '-c', '1', '-r', RATE, out] },
+];
+/** The first recording tool this machine has, or null. */
+function recorder() {
+    return RECORDERS.find((r) => present(r.command)) ?? null;
+}
+/**
+ * What to tell somebody who has no recording tool, or null when they do.
+ *
+ * One sentence and one command. Not a list of three options with trade-offs:
+ * somebody who just wanted to say a sentence out loud is not shopping for audio
+ * software.
+ */
+function missing() {
+    if (recorder())
+        return null;
+    return process.platform === 'darwin'
+        ? 'Speaking needs a recording tool, and macOS does not come with one. '
+            + 'Install it once with:  brew install sox'
+        : 'Speaking needs a recording tool. Install it once with:  '
+            + 'sudo apt install sox   (or your system\'s package manager)';
+}
+/**
+ * Start listening.
+ *
+ * Throws when there is nothing to listen with, which the caller should have
+ * headed off with `missing` so the person gets a sentence rather than an error.
+ */
+function start() {
+    const tool = recorder();
+    if (!tool)
+        throw new Error(missing() ?? 'No recording tool.');
+    const file = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'comprism-voice-')), 'said.wav');
+    const child = (0, node_child_process_1.spawn)(tool.command, tool.args(file), {
+        stdio: ['ignore', 'ignore', 'ignore'],
+    });
+    let stopped = null;
+    // The recorder never outlives the session. Closing the window or ending the
+    // process while it listens would otherwise leave a microphone recording to a
+    // file nobody knows about, the worst thing this tool could do.
+    const abandon = () => {
+        try {
+            child.kill('SIGKILL');
+        }
+        catch { /* already gone */ }
+        discard(file);
+    };
+    const onSignal = (signal) => {
+        abandon();
+        release();
+        process.kill(process.pid, signal);
+    };
+    const release = () => {
+        process.off('exit', abandon);
+        process.off('SIGHUP', onSignal);
+        process.off('SIGTERM', onSignal);
+    };
+    process.once('exit', abandon);
+    process.once('SIGHUP', onSignal);
+    process.once('SIGTERM', onSignal);
+    child.once('close', release);
+    const stop = () => {
+        if (stopped)
+            return stopped;
+        stopped = new Promise((resolve) => {
+            const done = () => {
+                let bytes = 0;
+                try {
+                    bytes = fs.statSync(file).size;
+                }
+                catch {
+                    bytes = 0;
+                }
+                resolve({ file, bytes });
+            };
+            // Interrupt, not kill. Every one of these tools finishes writing the WAV
+            // header on an interrupt and none of them does on a kill, and a header
+            // that was never finished reads as silence to whoever transcribes it.
+            child.once('close', done);
+            try {
+                child.kill('SIGINT');
+            }
+            catch {
+                done();
+            }
+            // A tool that has not closed in two seconds is not going to. Taking the
+            // file as it stands beats leaving somebody at a prompt that has stopped
+            // answering them.
+            setTimeout(() => {
+                try {
+                    child.kill('SIGKILL');
+                }
+                catch { /* already gone */ }
+                done();
+            }, 2000).unref();
+        });
+        return stopped;
+    };
+    return { file, by: tool.name, stop };
+}
+/** Delete the recording and the folder holding it. Always, and immediately. */
+function discard(file) {
+    try {
+        fs.rmSync(path.dirname(file), { recursive: true, force: true });
+    }
+    catch { /* a temp file we could not remove is not worth a word to anybody */ }
+}

package/out/providers/index.js

@@ -19,6 +19,7 @@ exports.callModel = callModel;
 const catalog_1 = require("../internal/catalog");
 const anthropic_1 = require("./anthropic");
 const openai_1 = require("./openai");
+const words_1 = require("../lib/words");
 var anthropic_2 = require("./anthropic");
 Object.defineProperty(exports, "ProviderHttpError", { enumerable: true, get: function () { return anthropic_2.ProviderHttpError; } });
 const DEFAULT_MAX_TOKENS = 4096;
@@ -62,7 +63,7 @@ async function callModel(call, keys) {
                 continue;
             }
             const latency = err instanceof anthropic_1.ProviderHttpError ? err.latencyMs : 0;
-            return errorResult(err instanceof Error ? err.message : 'provider call failed', latency);
+            return errorResult(err instanceof Error ? err.message : (0, words_1.word)('providerCallFailed'), latency);
         }
     }
     return errorResult('provider call failed', 0);

package/out/thin.js

@@ -56,7 +56,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
  */
 const ui = __importStar(require("./lib/ui"));
 const version_1 = require("./lib/version");
-const self_1 = require("./lib/self");
+const self_1 = require("./machine/runtime/self");
+const words_1 = require("./lib/words");
 const out = (s = '') => process.stdout.write(s + '\n');
 /** A refusal a script reads: always on standard error (Appendix B). */
 const err = (s = '') => process.stderr.write(s + '\n');
@@ -115,24 +116,25 @@ function usage() {
     out();
     out(ui.table(['COMMAND', 'WHAT IT DOES'], [
         ['comprism ask "<your question>"', 'one prompt, one answer, and what it cost'],
-        ['comprism work', 'have it do the work: reads your project, edits, runs your tests'],
+        ['comprism work', 'have it do the work: reads your workspace, edits, runs your tests'],
         ['comprism login', 'sign in with your email and password'],
         ['comprism', 'start a session and just type your questions'],
-        ['comprism --continue', 'carry on the most recent session in this project'],
+        ['comprism --continue', 'carry on the most recent session in this workspace'],
         ['comprism --resume [number]', 'carry on a session; with no number, choose from a list'],
         ['comprism sessions', 'your recent sessions, newest first; --search to find one'],
         ['comprism keys', 'add a provider key, or point at a file of them'],
         ['comprism model', 'the model your savings are measured against'],
         ['comprism providers', 'every AI vendor and model, and what you can reach'],
-        ['comprism project', 'the folder to work in, default is where you are'],
+        ['comprism workspace', 'the folder to work in, default is where you are'],
         ['comprism config', 'settings in force and where each came from'],
         ['comprism instructions', 'the instructions the next job receives'],
-        ['comprism memory', 'this project\'s notes'],
+        ['comprism memory', 'this workspace\'s notes'],
         ['comprism skills', 'the skills here and where each came from; /name runs one'],
         ['comprism integrations', 'outside tools the agent can call, and their sign in'],
         ['comprism plugins', 'packs of skills, helpers, hooks and connections'],
         ['comprism worktrees', 'separate copies of the repository'],
         ['comprism privacy', 'what your company keeps about your work'],
+        ['comprism decision-engine', 'whether your work uses a decision engine; add none or jev to change it'],
         ['comprism permissions', 'the rules in force here; permissions why <action> "<target>"'],
         ['comprism status', 'is this machine signed in, and to what'],
         ['comprism check', 'what this machine still needs, and how to add it'],
@@ -307,6 +309,12 @@ async function main() {
             process.exitCode = await cmdPrivacy();
             return;
         }
+        // Whether your work uses a decision engine (web manual 11.4).
+        case 'decision-engine': {
+            const { cmdDecisionEngine } = await Promise.resolve().then(() => __importStar(require('./commands/decisionEngine')));
+            process.exitCode = await cmdDecisionEngine(args);
+            return;
+        }
         // Separate copies of the repository (manual 2.11).
         case 'worktrees': {
             const { cmdWorktrees } = await Promise.resolve().then(() => __importStar(require('./commands/worktrees')));
@@ -378,7 +386,7 @@ async function main() {
             const reply = await askGateway({ intent: 'usage', prompt: '', tzMinutes: -new Date().getTimezoneOffset() });
             const found = reply.usage;
             if (!reply.ok || reply.served === false || !found?.lines) {
-                err(ui.fail(reply.message || 'Usage could not be read from your workspace.'));
+                err(ui.fail(reply.message || 'Usage could not be read from your organization.'));
                 process.exitCode = exitFor(reply.httpStatus === 401 ? 'signed_out'
                     : reply.ok || reply.httpStatus ? 'incomplete' : 'unreachable');
                 return;
@@ -400,7 +408,7 @@ async function main() {
             const reply = await askGateway({ intent: 'schema', prompt: '' });
             const doc = reply.schema_doc;
             if (!reply.ok || reply.served === false || !doc?.output) {
-                err(ui.fail(reply.message || 'The schema could not be read from your workspace.'));
+                err(ui.fail(reply.message || 'The schema could not be read from your organization.'));
                 const { exitFor } = await Promise.resolve().then(() => __importStar(require('./lib/output')));
                 process.exitCode = exitFor(reply.httpStatus === 401 ? 'signed_out'
                     : reply.ok || reply.httpStatus ? 'incomplete' : 'unreachable');
@@ -512,7 +520,7 @@ async function main() {
             const slashWord = /^\/([a-z][a-z0-9-]*)(?:\s|$)/i.exec(request.trim());
             if (slashWord && !(await Promise.resolve().then(() => __importStar(require('./lib/attach')))).startsWithPath(request.trim())) {
                 const { fetchCommandList } = await Promise.resolve().then(() => __importStar(require('./lib/commandlist')));
-                const { resolveProject } = await Promise.resolve().then(() => __importStar(require('./lib/project')));
+                const { resolveProject } = await Promise.resolve().then(() => __importStar(require('./machine/folder/project')));
                 const where = flag(args, '--cwd') ?? (await Promise.resolve().then(() => __importStar(require('./commands/settings')))).currentWorkspace().path;
                 const list = await fetchCommandList(resolveProject(where).root, []);
                 const name = slashWord[1].toLowerCase();
@@ -562,7 +570,7 @@ async function main() {
                 ?? (await Promise.resolve().then(() => __importStar(require('./commands/settings')))).currentWorkspace().path;
             const worktree = flag(args, '--worktree');
             if (worktree) {
-                const { checkFolder, resolveProject } = await Promise.resolve().then(() => __importStar(require('./lib/project')));
+                const { checkFolder, resolveProject } = await Promise.resolve().then(() => __importStar(require('./machine/folder/project')));
                 const start = checkFolder(workFolder);
                 if (!start.ok) {
                     out(ui.fail(start.why));
@@ -842,6 +850,6 @@ async function main() {
     }
 }
 main().catch((err) => {
-    process.stderr.write(ui.fail(err instanceof Error ? err.message : 'something went wrong') + '\n');
+    process.stderr.write(ui.fail(err instanceof Error ? err.message : (0, words_1.word)('somethingWrong')) + '\n');
     process.exitCode = 1;
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@illuminis/comprism",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "CompletionPrism Companion. Records what finishing a piece of work actually costs - every attempt, and the human time spent noticing and repairing the ones that failed.",
   "license": "UNLICENSED",
   "private": false,
@@ -23,8 +23,8 @@
     "node": ">=22"
   },
   "scripts": {
-    "build": "tsc -p ./ && node scripts/build-native.mjs",
-    "dev": "tsc -w -p ./",
+    "build": "node scripts/sync-machine-services.mjs && tsc -p ./ && node scripts/build-native.mjs",
+    "dev": "node scripts/sync-machine-services.mjs && tsc -w -p ./",
     "test": "npm run build && node --test out/**/*.test.js",
     "gate": "npm run build && npm test && npm run shipcheck",
     "prepublishOnly": "npm run build",
@@ -44,7 +44,7 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Illuminis-ai/completionprism.git",
-    "directory": "app/cli"
+    "directory": "app/frontend/terminal"
   },
   "keywords": [
     "ai",