@oxygen-agent/cli 1.377.3 → 1.575.19

package/dist/skills.js

@@ -10,6 +10,16 @@ import { resolveCmdShimInvocation } from "./windows-shim.js";
 const DEFAULT_SKILL_AGENTS = ["codex", "claude-code", "cursor"];
 const SKILL_INDEX_PATH = "/.well-known/skills/index.json";
 const SKILLS_ACCESS_API_PATH = "/api/cli/skills/access";
+// Display names the vendored `npx skills` installer (1.5.x) uses in its own
+// "Failed to install" console lines (`✗ <skill> → <displayName>: <reason>`).
+// Only used to tell a genuine failure of an agent we actually requested apart
+// from an agent name the installer swept in on its own — see
+// classifyInstallerFailures below.
+const AGENT_DISPLAY_NAMES = {
+    codex: "Codex",
+    "claude-code": "Claude Code",
+    cursor: "Cursor",
+};
 /**
  * Resolves where to install skills from. Logged-in CLIs mint a short-lived
  * org-bound access URL (the skills surface is gated; anonymous serving is
@@ -136,6 +146,7 @@ options, runtime = {}) {
     // passed straight through as before.
     let stagingDir = null;
     const outputs = [];
+    const skippedTargets = [];
     try {
         let installSource = source.install_url;
         if (source.authenticated) {
@@ -174,6 +185,22 @@ options, runtime = {}) {
                     exitCode: 1,
                 });
             }
+            // A 0 exit code alone doesn't mean every requested agent succeeded (see
+            // classifyInstallerFailures) — check the installer's own per-target report.
+            const { failed, skipped } = classifyInstallerFailures(stdout, agents);
+            if (failed.length > 0) {
+                throw new OxygenError("skills_install_failed", "Unable to install Oxygen agent skills.", {
+                    details: {
+                        index_url: source.index_url,
+                        authenticated: source.authenticated,
+                        skill: target,
+                        failed_targets: failed,
+                        stdout: stdout.slice(0, 2000),
+                    },
+                    exitCode: 1,
+                });
+            }
+            skippedTargets.push(...skipped);
             outputs.push(stdout);
         }
     }
@@ -181,6 +208,10 @@ options, runtime = {}) {
         if (stagingDir)
             rmSync(stagingDir, { recursive: true, force: true });
     }
+    // Every requested agent that didn't throw above installed cleanly. Agents the
+    // installer swept in beyond what we requested are reported distinctly and
+    // never counted as a failure — see classifyInstallerFailures.
+    const skippedAgents = [...new Set(skippedTargets.map((entry) => entry.agent))];
     if (dependencySkills.length > 0) {
         process.stderr.write(`note: '${skill}' also installs its prerequisite skill(s): ${dependencySkills.join(", ")}.\n`);
     }
@@ -195,6 +226,15 @@ options, runtime = {}) {
         ...(dependencySkills.length > 0 ? { dependency_skills: dependencySkills } : {}),
         scope: options.project ? "project" : "global",
         output: outputs.join(""),
+        // Truthful counts a caller (human or scripting agent) can trust at a
+        // glance: a not-detected agent is never folded into `failed`.
+        agents_installed: agents,
+        installed_count: agents.length,
+        ...(skippedAgents.length > 0 ? { agents_skipped: skippedAgents } : {}),
+        skipped_count: skippedAgents.length,
+        // Any genuine failure threw above rather than reaching this return.
+        failed_count: 0,
+        summary: summarizeInstallOutcome(agents.length, skippedAgents.length, 0),
     };
 }
 /**
@@ -590,7 +630,17 @@ function installerAddArgs(indexUrl, agents, skill) {
         "skills",
         "add",
         indexUrl,
-        "--agents",
+        // The installer's own parser only recognizes the singular `-a`/`--agent`
+        // flag (confirmed against `npx skills --help`, 1.5.x). The plural
+        // `--agents` this used to send is silently dropped as an unrecognized
+        // flag, so our explicit agent list never reaches the installer at all —
+        // it falls through to its own "no --agent given" auto-detect path, which
+        // (non-interactively, via --yes) sweeps in every agent sharing the
+        // universal `.agents/skills` convention (Codex, Cursor, but also things
+        // like PromptScript/Neovate/Pochi/Zenflow the user never asked for and
+        // that don't all support `--global`), producing a wall of unrelated
+        // "Failed" lines for agents this install was never targeting.
+        "--agent",
         ...agents,
         "--yes",
         "--skill",
@@ -598,6 +648,61 @@ function installerAddArgs(indexUrl, agents, skill) {
         "--full-depth",
     ];
 }
+// The installer's exit code doesn't reflect write-level (skill, agent)
+// failures — `npx skills add` (1.5.x) exits 0 even when individual targets
+// failed, reporting them only in a "Failed to install N" console section
+// (there is no --json mode for `add` and no per-target exit code). Reading
+// that text is the only signal available: a failure naming one of the agents
+// we actually requested is real and must still surface as a failure; a
+// failure naming any other agent means the installer targeted something this
+// install was never for (see installerAddArgs) — report that as skipped, not
+// a failure, so an agent that merely isn't on this machine never reads as
+// "something is broken."
+/** "GitHub Copilot" and "github-copilot" are the same agent; compare them as one. */
+function slugifyAgentLabel(label) {
+    return label.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function classifyInstallerFailures(stdout, requestedAgents) {
+    const plain = stdout.replace(/\x1B\[[0-9;]*m/g, "");
+    // The installer labels each line with the agent's DISPLAY name ("GitHub
+    // Copilot") while we requested its slug ("github-copilot"). Matching through a
+    // hand-maintained display-name map silently misclassified every agent missing
+    // from it — ~27 of the installer's targets have displayName ≠ slug — turning a
+    // real permission error into a reassuring "skipped, not detected". Slugify both
+    // sides instead, so the comparison cannot rot as the installer adds agents.
+    const requestedNames = new Set(requestedAgents.flatMap((agent) => [slugifyAgentLabel(agent), slugifyAgentLabel(AGENT_DISPLAY_NAMES[agent] ?? agent)]));
+    const failed = [];
+    const skipped = [];
+    const lineRe = /✗\s+(.+?)\s+→\s+(.+?):\s+(.+)/g;
+    let match;
+    while ((match = lineRe.exec(plain))) {
+        const skillName = match[1]?.trim();
+        const agentLabel = match[2]?.trim();
+        const reason = match[3]?.trim();
+        if (!skillName || !agentLabel || !reason)
+            continue;
+        if (requestedNames.has(slugifyAgentLabel(agentLabel))) {
+            failed.push({ skill: skillName, agent: agentLabel, reason });
+        }
+        else {
+            skipped.push({ skill: skillName, agent: agentLabel });
+        }
+    }
+    return { failed, skipped };
+}
+// Truthful, non-alarming one-line summary for both human and --json readers:
+// counts what actually happened instead of letting a "not detected" target
+// read like a broken install.
+function summarizeInstallOutcome(installedAgents, skippedAgents, failedAgents) {
+    const parts = [`installed for ${installedAgents} agent${installedAgents === 1 ? "" : "s"}`];
+    if (skippedAgents > 0) {
+        parts.push(`skipped ${skippedAgents} agent${skippedAgents === 1 ? "" : "s"} not detected on this machine`);
+    }
+    if (failedAgents > 0) {
+        parts.push(`${failedAgents} agent${failedAgents === 1 ? "" : "s"} failed`);
+    }
+    return `${parts.join("; ")}.`;
+}
 function readWords(value) {
     const text = Array.isArray(value) ? value.join(" ") : value;
     return text

package/node_modules/@oxygen/formula/dist/coerce.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The one coercion helper the formula engine needs. Kept here (rather than
+ * imported from a host package) so the engine stays dependency-free and
+ * browser-safe; tenant-db re-exports it from its own `coerce.ts` so the
+ * existing internal import path keeps working.
+ */
+/** Loose record check: any non-array object (class instances included). */
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/node_modules/@oxygen/formula/dist/coerce.js

@@ -0,0 +1,10 @@
+/**
+ * The one coercion helper the formula engine needs. Kept here (rather than
+ * imported from a host package) so the engine stays dependency-free and
+ * browser-safe; tenant-db re-exports it from its own `coerce.ts` so the
+ * existing internal import path keeps working.
+ */
+/** Loose record check: any non-array object (class instances included). */
+export function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/node_modules/@oxygen/formula/dist/evaluate.d.ts

@@ -0,0 +1,31 @@
+import { type FormulaAst, type ParseOptions } from "./expression.js";
+/**
+ * Expression evaluation. The engine never sees the host's data shape: every
+ * bare identifier goes through `FormulaScope.resolve`, so the same evaluator
+ * serves a tenant-db table row, a workflow node's inputs, and a browser
+ * preview pane with no host imports.
+ */
+/** Cross-row corpus, keyed by the column key the corpus was loaded for. */
+export type FormulaCrossRowCorpus = Record<string, readonly string[]>;
+export type FormulaScope = {
+    /**
+     * Resolve a bare identifier to a value. Throw (with
+     * `formulaExpressionError`) when the identifier is not in scope — a typo'd
+     * reference must fail loudly rather than silently evaluate to null.
+     */
+    resolve(identifier: string): unknown;
+    /**
+     * Lenient read used only by cross-row functions, which take a column key
+     * rather than an in-scope identifier and treat an absent value as blank.
+     * Omit it and the strict `resolve` is used, with its throw absorbed.
+     */
+    resolveOptional?(identifier: string): unknown;
+    /** Cross-row corpus, required by `novelty_score`. */
+    corpus?: FormulaCrossRowCorpus;
+    /** The key being computed — carried for self-reference guards. */
+    selfKey?: string;
+};
+export declare function evaluateFormulaInScope(expression: string, scope: FormulaScope, options?: ParseOptions): unknown;
+export declare function evaluateFormulaAst(node: FormulaAst, scope: FormulaScope): unknown;
+/** Coerce a formula result to the boolean gate decision used for run conditions. */
+export declare function isTruthyFormulaResult(value: unknown): boolean;

package/node_modules/@oxygen/formula/dist/evaluate.js

@@ -0,0 +1,248 @@
+import { OxygenError } from "@oxygen/shared/cli-result";
+import { isRecord } from "./coerce.js";
+import { CROSS_ROW_FUNCTIONS, parseFormulaExpression, } from "./expression.js";
+import { FORMULA_FUNCTION_REGISTRY, checkFormulaFunctionArity, compareFormulaValues, formulaExpressionError, formulaValuesEqual, readFormulaNumber, toFormulaBoolean, } from "./formula-functions.js";
+export function evaluateFormulaInScope(expression, scope, options = {}) {
+    return evaluateFormulaAst(parseFormulaExpression(expression, options), scope);
+}
+export function evaluateFormulaAst(node, scope) {
+    switch (node.type) { // skipcq: JS-0047
+        case "literal":
+            return node.value;
+        case "identifier":
+            return scope.resolve(node.name);
+        case "unary":
+            return evaluateUnary(node.operator, evaluateFormulaAst(node.argument, scope));
+        case "binary":
+            return evaluateBinary(node.operator, () => evaluateFormulaAst(node.left, scope), () => evaluateFormulaAst(node.right, scope));
+        case "call": {
+            const normalized = node.name.toLowerCase();
+            if (CROSS_ROW_FUNCTIONS.has(normalized)) {
+                return evaluateCrossRowFunction({ name: normalized, args: node.args, scope });
+            }
+            const spec = FORMULA_FUNCTION_REGISTRY.get(normalized);
+            if (spec)
+                checkFormulaFunctionArity(spec, node.args.length);
+            if (spec?.lazy && spec.evaluateLazy) {
+                return spec.evaluateLazy(node.args.map((arg) => () => evaluateFormulaAst(arg, scope)));
+            }
+            if (spec?.evaluate) {
+                return spec.evaluate(node.args.map((arg) => evaluateFormulaAst(arg, scope)));
+            }
+            throw formulaExpressionError("Unsupported formula function.", {
+                function: node.name,
+            });
+        }
+    }
+}
+/** Coerce a formula result to the boolean gate decision used for run conditions. */
+export function isTruthyFormulaResult(value) {
+    if (typeof value === "boolean")
+        return value;
+    if (typeof value === "number")
+        return value !== 0;
+    if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        return normalized !== "" && normalized !== "false" && normalized !== "0" && normalized !== "no";
+    }
+    return value !== null && value !== undefined;
+}
+function evaluateCrossRowFunction(input) {
+    if (input.name !== "novelty_score") {
+        throw formulaExpressionError("Unsupported cross-row formula function.", {
+            function: input.name,
+        });
+    }
+    const firstArg = input.args[0];
+    if (input.args.length !== 1 || !firstArg) {
+        throw formulaExpressionError("novelty_score requires exactly one column argument.", {
+            function: input.name,
+            received: input.args.length,
+        });
+    }
+    const targetColumnKey = readCrossRowColumnArg(firstArg, input.name);
+    if (!input.scope.corpus) {
+        throw new OxygenError("novelty_score_corpus_unavailable", "novelty_score requires a sync columns run on the current table so the column corpus can be loaded.", {
+            details: {
+                column_key: targetColumnKey,
+                function: input.name,
+                hint: "Re-run with `oxygen columns run` (sync) instead of `--background` so the corpus is available.",
+            },
+            exitCode: 1,
+        });
+    }
+    const corpus = input.scope.corpus[targetColumnKey];
+    if (!corpus) {
+        throw new OxygenError("novelty_score_corpus_unavailable", `novelty_score corpus for column ${targetColumnKey} is empty or was not provided.`, {
+            details: { column_key: targetColumnKey, function: input.name },
+            exitCode: 1,
+        });
+    }
+    const cellValue = stringifyNoveltyValue(readOptionalValue(input.scope, targetColumnKey));
+    if (!cellValue)
+        return null;
+    const noveltyScore = computeNoveltyScore(cellValue, corpus);
+    return Math.round(noveltyScore * 10_000) / 10_000;
+}
+/**
+ * Cross-row functions take a column key, not an in-scope identifier: a column
+ * that exists in the corpus but not on this row scores as blank instead of
+ * failing the row. Scopes that can answer leniently supply `resolveOptional`;
+ * otherwise the strict resolver's unknown-identifier throw is absorbed here.
+ */
+function readOptionalValue(scope, identifier) {
+    if (scope.resolveOptional)
+        return scope.resolveOptional(identifier);
+    try {
+        return scope.resolve(identifier);
+    }
+    catch {
+        return undefined;
+    }
+}
+function readCrossRowColumnArg(node, functionName) {
+    if (node.type === "identifier")
+        return node.name;
+    if (node.type === "literal" && typeof node.value === "string")
+        return node.value;
+    throw formulaExpressionError("Cross-row function requires a column key argument.", {
+        function: functionName,
+    });
+}
+function stringifyNoveltyValue(value) {
+    if (value === null || value === undefined)
+        return "";
+    if (typeof value === "string")
+        return value.trim();
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value).trim();
+    if (Array.isArray(value)) {
+        return value
+            .map((entry) => stringifyNoveltyValue(entry))
+            .filter((entry) => entry.length > 0)
+            .join(" ")
+            .trim();
+    }
+    if (isRecord(value)) {
+        const preferred = value.body ?? value.text ?? value.email ?? value.message;
+        if (typeof preferred === "string")
+            return preferred.trim();
+        return JSON.stringify(value);
+    }
+    return "";
+}
+const NOVELTY_SHINGLE_SIZE = 5;
+function computeNoveltyScore(cellValue, corpus) {
+    const cellShingles = buildShingleSet(cellValue);
+    if (cellShingles.size === 0)
+        return 1;
+    let maxOverlap = 0;
+    let skippedSelfMatch = false;
+    for (const other of corpus) {
+        if (other === cellValue && !skippedSelfMatch) {
+            skippedSelfMatch = true;
+            continue;
+        }
+        const otherShingles = buildShingleSet(other);
+        if (otherShingles.size === 0)
+            continue;
+        const overlap = jaccardSimilarity(cellShingles, otherShingles);
+        if (overlap > maxOverlap)
+            maxOverlap = overlap;
+    }
+    const novelty = 1 - maxOverlap;
+    if (novelty < 0)
+        return 0;
+    if (novelty > 1)
+        return 1;
+    return novelty;
+}
+function buildShingleSet(value) {
+    const normalized = value
+        .toLowerCase()
+        .replace(/[^a-z0-9\s]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    const tokens = normalized ? normalized.split(" ") : [];
+    const shingles = new Set();
+    if (tokens.length < NOVELTY_SHINGLE_SIZE) {
+        if (tokens.length > 0)
+            shingles.add(tokens.join(" "));
+        return shingles;
+    }
+    for (let i = 0; i <= tokens.length - NOVELTY_SHINGLE_SIZE; i += 1) {
+        shingles.add(tokens.slice(i, i + NOVELTY_SHINGLE_SIZE).join(" "));
+    }
+    return shingles;
+}
+function jaccardSimilarity(left, right) {
+    let intersection = 0;
+    const [smaller, larger] = left.size <= right.size ? [left, right] : [right, left];
+    for (const entry of smaller) {
+        if (larger.has(entry))
+            intersection += 1;
+    }
+    const union = left.size + right.size - intersection;
+    return union === 0 ? 0 : intersection / union;
+}
+function evaluateUnary(operator, value) {
+    switch (operator) {
+        case "+":
+            return readFormulaNumber(value, operator);
+        case "-":
+            return -readFormulaNumber(value, operator);
+        case "not":
+            return !toFormulaBoolean(value);
+        default:
+            throw formulaExpressionError("Unsupported unary operator.", { operator });
+    }
+}
+function evaluateBinary(// skipcq: JS-R1005
+operator, leftThunk, rightThunk) {
+    if (operator === "and") {
+        return toFormulaBoolean(leftThunk()) && toFormulaBoolean(rightThunk());
+    }
+    if (operator === "or") {
+        return toFormulaBoolean(leftThunk()) || toFormulaBoolean(rightThunk());
+    }
+    const left = leftThunk();
+    const right = rightThunk();
+    switch (operator) {
+        case "=":
+        case "==":
+            return formulaValuesEqual(left, right);
+        case "!=":
+        case "<>":
+            return !formulaValuesEqual(left, right);
+        case "<":
+            return compareFormulaValues(left, right) < 0;
+        case "<=":
+            return compareFormulaValues(left, right) <= 0;
+        case ">":
+            return compareFormulaValues(left, right) > 0;
+        case ">=":
+            return compareFormulaValues(left, right) >= 0;
+        case "+":
+            return readFormulaNumber(left, operator) + readFormulaNumber(right, operator);
+        case "-":
+            return readFormulaNumber(left, operator) - readFormulaNumber(right, operator);
+        case "*":
+            return readFormulaNumber(left, operator) * readFormulaNumber(right, operator);
+        case "/": {
+            const divisor = readFormulaNumber(right, operator);
+            if (divisor === 0) {
+                throw formulaExpressionError("Formula division by zero.", { operator });
+            }
+            return readFormulaNumber(left, operator) / divisor;
+        }
+        case "%": {
+            const divisor = readFormulaNumber(right, operator);
+            if (divisor === 0) {
+                throw formulaExpressionError("Formula modulo by zero.", { operator });
+            }
+            return readFormulaNumber(left, operator) % divisor;
+        }
+        default:
+            throw formulaExpressionError("Unsupported binary operator.", { operator });
+    }
+}

package/node_modules/@oxygen/formula/dist/expression.d.ts

@@ -0,0 +1,64 @@
+/** The parsed expression tree. Identifiers are resolved by a FormulaScope. */
+export type FormulaAst = {
+    type: "literal";
+    value: unknown;
+} | {
+    type: "identifier";
+    name: string;
+} | {
+    type: "unary";
+    operator: string;
+    argument: FormulaAst;
+} | {
+    type: "binary";
+    operator: string;
+    left: FormulaAst;
+    right: FormulaAst;
+} | {
+    type: "call";
+    name: string;
+    args: FormulaAst[];
+};
+/**
+ * Functions evaluated against the whole column rather than the current scope.
+ * They are intercepted before registry dispatch (the registry entry carries
+ * metadata only) because they need a corpus the scope supplies.
+ */
+export declare const CROSS_ROW_FUNCTIONS: ReadonlySet<string>;
+/**
+ * How to tokenize. One flag today, and it is deliberately opt-in: a table formula
+ * must parse byte-identically to before this existed.
+ */
+export type ParseOptions = {
+    /**
+     * Let an identifier carry `.field` and `[0]` segments, so `steps.enrich.email`
+     * is one identifier rather than a syntax error. Workflow expressions set this;
+     * table formulas do not, because a bare column name is their whole vocabulary and
+     * `a.b` there should stay the error it has always been.
+     */
+    paths?: boolean;
+};
+export declare function parseFormulaExpression(expression: string, options?: ParseOptions): FormulaAst;
+/** Validate supported functions and arity on an already-parsed tree. */
+export declare function validateFormulaAst(ast: FormulaAst): void;
+/** Validate syntax, supported functions, and arity without evaluating any data. */
+export declare function validateFormulaExpression(expression: string, options?: ParseOptions): void;
+export declare function walkExpression(node: FormulaAst, visit: (node: FormulaAst) => void): void;
+export declare function analyzeCrossRowDependencies(node: FormulaAst): {
+    functions: string[];
+    columnKeys: string[];
+};
+export declare function analyzeFormulaCrossRowDependencies(expression: string): {
+    functions: string[];
+    columnKeys: string[];
+};
+/**
+ * Every identifier the expression reads, plus its cross-row dependencies.
+ * Identifiers are bare names — the host decides what they bind to (a table
+ * column key today, a workflow node output tomorrow).
+ */
+export declare function analyzeFormulaDependencies(expression: string, options?: ParseOptions): {
+    identifiers: string[];
+    crossRowFunctions: string[];
+    crossRowColumnKeys: string[];
+};