myrmo 0.9.0 → 0.10.1

package/dist/client.d.ts

@@ -2,7 +2,7 @@ import { type RedactionReport } from "./redact.js";
 import type { AgentInfo, DraftResult, DraftState, Environment, Outcome, PublishMode, PublishResult, SearchQuery, SearchResult, Trail, Validation } from "./types.js";
 /** The public colony. Override with MYRMO_URL or the `url` option. */
 export declare const DEFAULT_URL = "https://myrmo.dev";
-export declare const SDK_VERSION = "0.9.0";
+export declare const SDK_VERSION = "0.10.1";
 export interface ColonyOptions {
     url?: string;
     apiKey?: string;
@@ -70,10 +70,15 @@ export declare class Colony {
         counted: boolean;
         strength: number;
     }>;
-    /** The trail exactly as it would be sent, with every redaction counted. Sends nothing. */
+    /**
+     * The trail exactly as it would be sent, with every redaction counted. Sends nothing. `names` lists runs of
+     * capitalised words that could be an organisation, customer, person or project: not redacted, to be checked by
+     * whoever approves.
+     */
     preview(trail: Trail): {
         trail: Trail;
         redactions: RedactionReport;
+        names: string[];
     };
     /**
      * Ask the colony whether it would accept this trail, without publishing it: the schema check publishing

package/dist/client.js

@@ -7,10 +7,11 @@
 import { agentIdentity, publishChoice } from "./config.js";
 import { detectEnvironment, parsePackage } from "./environment.js";
 import { fingerprint2, guessErrorType } from "./fingerprint.js";
-import { redactText, redactValue } from "./redact.js";
+import { namesConflict } from "./names.js";
+import { possibleNames, redactText, redactValue } from "./redact.js";
 /** The public colony. Override with MYRMO_URL or the `url` option. */
 export const DEFAULT_URL = "https://myrmo.dev";
-export const SDK_VERSION = "0.9.0"; // x-release-please-version
+export const SDK_VERSION = "0.10.1"; // x-release-please-version
 /** What a colony that is restarting or overloaded answers with. */
 const UNAVAILABLE = new Set([502, 503, 504]);
 const DEFAULT_RETRY_DELAYS_MS = [500, 1500, 3000];
@@ -161,8 +162,11 @@ export class Colony {
         const error = redactText(query.error);
         const errorType = query.errorType ?? guessErrorType(error);
         const fp = fingerprint2(error);
-        const exact = await this.lookup(fp, query.model);
-        if (exact && exact.hits.length > 0)
+        // fp2 erases the module path, image or repository an error names: an exact hit about another one is no answer.
+        const found = await this.lookup(fp, query.model);
+        const kept = found?.hits.filter((hit) => !namesConflict(error, String(hit.trail?.problem?.error_message ?? ""))) ?? [];
+        const exact = found && kept.length > 0 ? (kept.length === found.hits.length ? found : { ...found, hits: kept }) : null;
+        if (exact)
             return exact;
         const environment = {
             ...detectEnvironment(),
@@ -203,10 +207,15 @@ export class Colony {
         this.cache.clear();
         return { trailId: data.trail_id, counted: data.counted, strength: data.strength };
     }
-    /** The trail exactly as it would be sent, with every redaction counted. Sends nothing. */
+    /**
+     * The trail exactly as it would be sent, with every redaction counted. Sends nothing. `names` lists runs of
+     * capitalised words that could be an organisation, customer, person or project: not redacted, to be checked by
+     * whoever approves.
+     */
     preview(trail) {
         const redactions = {};
-        return { trail: redactValue(trail, redactions), redactions };
+        const redacted = redactValue(trail, redactions);
+        return { trail: redacted, redactions, names: possibleNames(redacted) };
     }
     /**
      * Ask the colony whether it would accept this trail, without publishing it: the schema check publishing

package/dist/format.js

@@ -89,7 +89,7 @@ export function formatResult(result, opts = {}) {
     if (hits.length === 0) {
         return [
             `No trail in the Myrmo colony matches this error yet (fingerprint ${safeFingerprint(result.fingerprint)}).`,
-            `Nothing found, so you may be the first to solve this one. If it takes ${attemptsPhrase(minFailedAttempts(opts.minFailedAttempts).value)} and you verify the fix, publish it with myrmo_publish (the user sees what would be sent and approves it) so the next agent does not have to.`,
+            `Carry on without it; searching again for the same line will not help. Afterwards, publishing is optional: only if solving it takes ${attemptsPhrase(minFailedAttempts(opts.minFailedAttempts).value)} and you verify the fix (myrmo_publish; the user approves what is sent).`,
         ].join("\n");
     }
     return [

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 export { Colony, MyrmoError, DEFAULT_URL, SDK_VERSION, type ColonyOptions } from "./client.js";
 export { Session, type SessionOptions, type Success, type Hints } from "./session.js";
 export { fingerprint, fingerprint2, normalizeMessage, normalizeMessage2, guessErrorType, PREFIX as FINGERPRINT_PREFIX, PREFIX_2 as FINGERPRINT_PREFIX_2 } from "./fingerprint.js";
-export { redactText, redactValue, type RedactionReport } from "./redact.js";
+export { namesConflict, placeholderNames } from "./names.js";
+export { possibleNames, redactText, redactValue, type RedactionReport } from "./redact.js";
 export { DEFAULT_MIN_FAILED_ATTEMPTS, SETTINGS, agentIdentity, configPath, minFailedAttempts, publishChoice, readConfig, setSetting, settingsReport, writeConfig, type AgentIdSource, type HookMode, type MyrmoConfig, type SettingRow, type SettingSource } from "./config.js";
 export { detectEnvironment, parsePackage } from "./environment.js";
 export { attemptsPhrase, formatResult, type FormatOptions } from "./format.js";

package/dist/index.js

@@ -1,7 +1,8 @@
 export { Colony, MyrmoError, DEFAULT_URL, SDK_VERSION } from "./client.js";
 export { Session } from "./session.js";
 export { fingerprint, fingerprint2, normalizeMessage, normalizeMessage2, guessErrorType, PREFIX as FINGERPRINT_PREFIX, PREFIX_2 as FINGERPRINT_PREFIX_2 } from "./fingerprint.js";
-export { redactText, redactValue } from "./redact.js";
+export { namesConflict, placeholderNames } from "./names.js";
+export { possibleNames, redactText, redactValue } from "./redact.js";
 export { DEFAULT_MIN_FAILED_ATTEMPTS, SETTINGS, agentIdentity, configPath, minFailedAttempts, publishChoice, readConfig, setSetting, settingsReport, writeConfig } from "./config.js";
 export { detectEnvironment, parsePackage } from "./environment.js";
 export { attemptsPhrase, formatResult } from "./format.js";

package/dist/names.d.ts

@@ -0,0 +1,3 @@
+export declare function placeholderNames(text: string): Set<string>;
+/** True when the query and the message both spell such names and share none: another package, so another error. */
+export declare function namesConflict(query: string, message: string): boolean;

package/dist/names.js

@@ -0,0 +1,88 @@
+// Names that fp2 erases, and whether two messages name different things.
+//
+// The fingerprint replaces paths, URLs and numbers by placeholders, so every `no required module provides package <module>`
+// is one key whatever the module. An exact lookup can therefore answer with a trail about another package. The names tell
+// them apart: a Go module path, the repository of a git URL, a registry package, a container image. Absolute paths, files and
+// numbers are the machine's and are not names.
+//
+// A port of `placeholder_names` in server/src/relevance.rs; protocol/placeholder_names.v1.vectors.json is normative and the
+// server and both SDKs must reproduce it exactly.
+const FILE_EXTENSIONS = new Set(("py js mjs cjs ts tsx jsx rs go java kt c h cc cpp hpp cs rb php json yaml yml toml lock xml csv txt md ini cfg conf sh log " +
+    "html css sql whl gz zip tar so dll exe pem crt key").split(" "));
+const SPLIT = /[\s'"`()[\]<>,;=]+/;
+const PUNCTUATION = /[:./]+$/;
+function nameOf(raw) {
+    let token = raw.toLowerCase();
+    const scheme = token.indexOf("://");
+    if (scheme !== -1)
+        token = token.slice(scheme + 3);
+    const cut = token.search(/[?#]/);
+    if (cut !== -1)
+        token = token.slice(0, cut);
+    // user:password@host/path: the credentials are not part of the name.
+    let at = token.indexOf("@");
+    if (at !== -1) {
+        const head = token.slice(0, at);
+        const tail = token.slice(at + 1);
+        if (head && !head.includes("/") && tail.includes("/"))
+            token = tail;
+    }
+    // name@1.2.3: the version is not part of the name.
+    at = token.lastIndexOf("@");
+    if (at !== -1) {
+        const head = token.slice(0, at);
+        const tail = token.slice(at + 1);
+        if (head.includes("/") && !tail.includes("/"))
+            token = head;
+    }
+    token = token.replace(PUNCTUATION, "");
+    if (token.endsWith(".git"))
+        token = token.slice(0, -4).replace(PUNCTUATION, "");
+    // An image tag, or a line and column (`main.rs:5:3`): a colon after the last slash ends the name.
+    const slash = token.lastIndexOf("/");
+    if (slash !== -1) {
+        const colon = token.indexOf(":", slash);
+        if (colon !== -1)
+            token = token.slice(0, colon);
+    }
+    if (!token.includes("/") || !/^[a-z0-9]/.test(token))
+        return null;
+    const segments = token.split("/");
+    if (segments.length > 8 || segments.some((segment) => segment === ""))
+        return null;
+    const last = segments[segments.length - 1];
+    if (last.includes(".") && FILE_EXTENSIONS.has(last.slice(last.lastIndexOf(".") + 1)))
+        return null;
+    const host = segments[0].split(":")[0];
+    const tld = host.includes(".") ? host.slice(host.lastIndexOf(".") + 1) : "";
+    const hostLike = host === "localhost" || (tld.length >= 2 && /^[a-z]+$/.test(tld));
+    const pair = segments.length === 2 && !segments[0].includes(".");
+    return (hostLike || pair) && /[a-z]/.test(token) ? token : null;
+}
+export function placeholderNames(text) {
+    const found = new Set();
+    for (const raw of text.split(SPLIT)) {
+        if (!raw)
+            continue;
+        const name = nameOf(raw);
+        if (name)
+            found.add(name);
+    }
+    return found;
+}
+function shareAName(a, b) {
+    const lastOf = (s) => s.slice(s.lastIndexOf("/") + 1);
+    for (const x of a)
+        for (const y of b)
+            if (x === y || x.startsWith(`${y}/`) || y.startsWith(`${x}/`) || lastOf(x) === lastOf(y))
+                return true;
+    return false;
+}
+/** True when the query and the message both spell such names and share none: another package, so another error. */
+export function namesConflict(query, message) {
+    const asked = placeholderNames(query);
+    if (asked.size === 0)
+        return false;
+    const have = placeholderNames(message);
+    return have.size > 0 && !shareAName(asked, have);
+}

package/dist/redact.d.ts

@@ -2,3 +2,9 @@ export type RedactionReport = Record<string, number>;
 export declare function redactText(input: string, report?: RedactionReport): string;
 /** Deep copy of `value` with every string redacted. */
 export declare function redactValue<T>(value: T, report?: RedactionReport): T;
+/**
+ * Runs of capitalised words that look like a name (`Acme Data Systems`), for a person to check before approving a
+ * publication. This does not redact anything: a name looks like any other word, so the colony cannot remove one by
+ * itself. A run at the start of a sentence loses its first word, which is capitalised anyway.
+ */
+export declare function possibleNames(value: unknown, limit?: number): string[];

package/dist/redact.js

@@ -55,6 +55,42 @@ const card = ([m]) => {
 };
 /** `name = value` becomes `name = <redacted:kind>` unless the value is a reference. */
 const keepPrefix = (kind, valueGroup) => (m) => isReference(m[valueGroup]) ? null : m.slice(1, valueGroup).join("") + full(kind);
+// Configuration values that name an organisation or a person: `edc.ui.organization=Acme`, `"owner": "Ana"`,
+// `LABEL maintainer=...`. The key decides, never the value, because a name looks like any other word. A key
+// matches only when its last part is one of these words, so `org.eclipse.edc:dcp-core` (a Maven coordinate) and
+// `--org-id` are left alone. A product or connector `*.title` is included: it is usually the owner's brand.
+const ORG_KEY = String.raw `(?:(?:[A-Za-z0-9_.\-]{0,64}[._\-])?(?:(?:organi[sz]ations?|org|compan(?:y|ies)|tenants?|customers?|owners?|authors?|` +
+    String.raw `contacts?|maintainers?|publishers?|vendors?|employers?)(?:[_.\-]?(?:name|title))?|` +
+    String.raw `(?:client|display|full|legal|trade|business|brand)[_.\-]?name)|` +
+    String.raw `(?:[A-Za-z0-9_.\-]{0,64}[._\-])?(?:connector|product|portal|brand|app|ui|site)[._\-](?:[A-Za-z0-9_.\-]{0,64}[._\-])?title)`;
+/** Values that are not a name: placeholders, types and generic words. */
+const ORG_KEEP = new Set([
+    "default", "unknown", "example", "test", "testing", "user", "users", "admin", "administrator", "root", "me",
+    "self", "system", "anonymous", "n/a", "na", "tbd", "todo", "unset", "any", "object", "dict", "list", "set",
+    "array", "map", "number", "float", "date", "datetime", "name", "author", "owner", "org", "organization",
+    "company", "customer", "tenant",
+]);
+/** A type annotation such as `Optional[str]`, not a name. */
+const ORG_TYPE = /^[A-Za-z_][A-Za-z0-9_.]*\[[A-Za-z0-9_., \[\]]*\]$/;
+/**
+ * The key of a rule anchored to the start of a line cannot begin with `-`, or the `-Dkey=value` of a command would
+ * take the rest of the command with it.
+ */
+const ORG_KEY_LINE = ORG_KEY.replace(String.raw `[A-Za-z0-9_.\-]{0,64}[._\-]`, String.raw `[A-Za-z0-9_][A-Za-z0-9_.\-]{0,63}[._\-]`);
+function orgKept(value, inline) {
+    const lower = value.toLowerCase();
+    return (isReference(value) ||
+        value.startsWith("<") ||
+        !/\p{L}/u.test(value) ||
+        ORG_TYPE.test(value) ||
+        ORG_KEEP.has(lower) ||
+        ["your", "example", "sample", "my-", "my_"].some((p) => lower.startsWith(p)) ||
+        (inline && [...value].some((c) => "${}[]()*\\".includes(c))));
+}
+/** Replaces the value group with `<redacted:org>`, keeping every group before and after it. */
+const orgValue = (valueGroup, inline) => (m) => orgKept(m[valueGroup], inline)
+    ? null
+    : m.slice(1).map((group, i) => (i + 1 === valueGroup ? full("org") : group)).join("");
 const SCHEMES = ["bearer", "basic", "token", "digest", "negotiate", "ntlm", "hawk"];
 const authorization = (m) => {
     const [, prefix, scheme, value] = m;
@@ -126,6 +162,10 @@ const RULES = [
     r("card", String.raw `\b[3-6](?:[ \-]?[0-9]){12,18}\b`, "", card),
     r("home_path", String.raw `(\/home\/|\/Users\/)[^/\s'\x22<>]+`, "", (m) => `${m[1]}<user>`),
     r("home_path", String.raw `([a-z]:\\Users\\)[^\\\s'\x22<>]+`, "i", (m) => `${m[1]}<user>`),
+    // The org rules come last: they match on the key, so every more specific kind has already had its turn.
+    r("org", String.raw `(^|[^A-Za-z0-9_.\-])(` + ORG_KEY + String.raw `['\x22]?[ \t]*[=:][ \t]*)(['\x22])([^'\x22\r\n]{2,120})(['\x22])`, "i", orgValue(4, false)),
+    r("org", String.raw `(^[ \t]*(?:-[ \t]+)?` + ORG_KEY_LINE + String.raw `['\x22]?[ \t]*[=:][ \t]*)([^\s'\x22<>][^\r\n]*?)([ \t]*\r?$)`, "im", orgValue(2, false)),
+    r("org", String.raw `(^|[^A-Za-z0-9_.\-])(` + ORG_KEY + String.raw `['\x22]?[ \t]*[=:][ \t]*)([^\s'\x22<>,;]{2,80})`, "i", orgValue(3, true)),
 ];
 export function redactText(input, report = {}) {
     let text = input;
@@ -160,3 +200,43 @@ export function redactValue(value, report = {}) {
     }
     return value;
 }
+/**
+ * Runs of capitalised words that look like a name (`Acme Data Systems`), for a person to check before approving a
+ * publication. This does not redact anything: a name looks like any other word, so the colony cannot remove one by
+ * itself. A run at the start of a sentence loses its first word, which is capitalised anyway.
+ */
+export function possibleNames(value, limit = 10) {
+    const found = new Set();
+    const capitalised = (w) => w.length >= 2 && w[0] !== w[0].toLowerCase();
+    const scan = (text) => {
+        let run = [];
+        const flush = () => {
+            if (run.length && /(?:^|[.!?:]\s+|\n\s*)$/.test(text.slice(0, run[0].index)))
+                run = run.slice(1);
+            if (run.length >= 2)
+                found.add(text.slice(run[0].index, run[run.length - 1].end));
+            run = [];
+        };
+        for (const m of text.matchAll(/\p{L}+/gu)) {
+            const word = { index: m.index ?? 0, end: (m.index ?? 0) + m[0].length };
+            if (!capitalised(m[0])) {
+                flush();
+                continue;
+            }
+            if (run.length && !(text[run[run.length - 1].end] === " " && run[run.length - 1].end + 1 === word.index))
+                flush();
+            run.push(word);
+        }
+        flush();
+    };
+    const walk = (v) => {
+        if (typeof v === "string")
+            scan(v);
+        else if (Array.isArray(v))
+            v.forEach(walk);
+        else if (v && typeof v === "object")
+            Object.values(v).forEach(walk);
+    };
+    walk(value);
+    return [...found].slice(0, limit);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myrmo",
-  "version": "0.9.0",
+  "version": "0.10.1",
   "description": "Myrmo SDK: shared memory of solved errors for AI agents. Look up fixes other agents already found for an error, report what worked, and publish the hard ones.",
   "license": "Apache-2.0",
   "homepage": "https://myrmo.dev",