@cortexkit/opencode-magic-context 0.14.0 → 0.14.2

package/dist/plugin/hooks/create-session-hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-session-hooks.d.ts","sourceRoot":"","sources":["../../../src/plugin/hooks/create-session-hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAU7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8CAA8C,CAAC;AACrF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACrC,GAAG,EAAE,aAAa,CAAC;IACnB,YAAY,EAAE,wBAAwB,CAAC;IACvC,gBAAgB,EAAE,gBAAgB,CAAC;CACtC;;;;;;qBAmD0f,CAAC;;;;;;;;;;;;qBAV5e,CAAP;mBAAyB,CAAC;iBACnB,CAAN;iBAAuB,CAAC;0BAClB,CAAd;uBAAiB,CAAC;;;;;;0BAQ8ujB,CAAC;;;;;;EADlwjB"}
+{"version":3,"file":"create-session-hooks.d.ts","sourceRoot":"","sources":["../../../src/plugin/hooks/create-session-hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAU7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8CAA8C,CAAC;AACrF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACrC,GAAG,EAAE,aAAa,CAAC;IACnB,YAAY,EAAE,wBAAwB,CAAC;IACvC,gBAAgB,EAAE,gBAAgB,CAAC;CACtC;;;;;;qBAmD4gD,CAAC;;;;;;;;;;;;qBAbz+C,CAAC;mBAAyB,CAAC;iBAChD,CAAX;iBAAuB,CAAC;0BAAc,CAAC;uBAAiB,CAAC;;;;;;0BAYokmB,CAAC;;;;;;EADlomB"}

package/dist/shared/error-message.d.ts

@@ -1,2 +1,32 @@
 export declare function getErrorMessage(error: unknown): string;
+/**
+ * Produce a rich, safe-to-log description of any thrown value.
+ *
+ * Motivated by SDK errors whose `.message` is empty while `.name`/`toString()`
+ * carry the actual signal (e.g. `NotFoundError` with no message on OpenCode
+ * session-delete races). Using {@link getErrorMessage} alone erases that signal.
+ *
+ * Captures:
+ * - `name` from the Error (defaults to `constructor.name`)
+ * - `message` (may be empty)
+ * - first few stack frames
+ * - `String(error)` so objects and custom toString surfaces are visible
+ * - Common HTTP-shape fields (`status`, `statusCode`, `code`)
+ * - `cause` chain summary (first level only)
+ *
+ * Returns a compact, single-line-friendly string suitable for log lines,
+ * plus a structured object for callers that want individual fields.
+ */
+export interface ErrorDescription {
+    name: string;
+    message: string;
+    status?: string;
+    code?: string;
+    causeName?: string;
+    stackHead?: string;
+    stringForm: string;
+    /** Best short summary for human-readable logs. Never empty. */
+    brief: string;
+}
+export declare function describeError(error: unknown): ErrorDescription;
 //# sourceMappingURL=error-message.d.ts.map

package/dist/shared/error-message.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error-message.d.ts","sourceRoot":"","sources":["../../src/shared/error-message.ts"],"names":[],"mappings":"AAAA,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEtD"}
+{"version":3,"file":"error-message.d.ts","sourceRoot":"","sources":["../../src/shared/error-message.ts"],"names":[],"mappings":"AAAA,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEtD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,gBAAgB;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAC;CACjB;AAaD,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,gBAAgB,CA6D9D"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/opencode-magic-context",
-  "version": "0.14.0",
+  "version": "0.14.2",
   "type": "module",
   "description": "OpenCode plugin for Magic Context — cross-session memory and context management",
   "main": "dist/index.js",

package/src/shared/error-message.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, it } from "bun:test";
+import { describeError, getErrorMessage } from "./error-message";
+
+describe("describeError", () => {
+    it("extracts name and message from standard Error", () => {
+        const err = new TypeError("boom");
+        const desc = describeError(err);
+        expect(desc.name).toBe("TypeError");
+        expect(desc.message).toBe("boom");
+        expect(desc.brief).toContain("TypeError");
+        expect(desc.brief).toContain('message="boom"');
+    });
+
+    it("surfaces class name when message is empty (NotFoundError case)", () => {
+        class NotFoundError extends Error {
+            constructor() {
+                super("");
+                this.name = "NotFoundError";
+            }
+        }
+        const err = new NotFoundError();
+        const desc = describeError(err);
+        expect(desc.name).toBe("NotFoundError");
+        expect(desc.message).toBe("");
+        // brief must still carry a useful signal even with empty message
+        expect(desc.brief).toContain("NotFoundError");
+    });
+
+    it("falls back to constructor.name when .name is missing", () => {
+        // Simulate an SDK-shaped object where .name is an empty string
+        const err = Object.assign(new Error("x"), { name: "" });
+        const desc = describeError(err);
+        // Falls back to constructor.name ("Error")
+        expect(desc.name).toBe("Error");
+    });
+
+    it("extracts status/code fields from HTTP-style errors", () => {
+        const err = Object.assign(new Error("not found"), {
+            status: 404,
+            code: "ENOTFOUND",
+        });
+        const desc = describeError(err);
+        expect(desc.status).toBe("404");
+        expect(desc.code).toBe("ENOTFOUND");
+        expect(desc.brief).toContain("status=404");
+        expect(desc.brief).toContain("code=ENOTFOUND");
+    });
+
+    it("captures first stack frames in stackHead", () => {
+        const err = new Error("with stack");
+        const desc = describeError(err);
+        expect(desc.stackHead).toBeDefined();
+        expect(desc.stackHead?.length).toBeGreaterThan(0);
+    });
+
+    it("handles non-Error thrown values", () => {
+        const desc = describeError("plain string");
+        expect(desc.brief).toContain("plain string");
+        expect(desc.stringForm).toContain("plain string");
+    });
+
+    it("handles objects without .message", () => {
+        const desc = describeError({ name: "WeirdError" });
+        expect(desc.name).toBe("WeirdError");
+        expect(desc.message).toBe("");
+        expect(desc.brief).toContain("WeirdError");
+    });
+
+    it("handles undefined/null", () => {
+        expect(describeError(undefined).brief).toBeTruthy();
+        expect(describeError(null).brief).toBeTruthy();
+    });
+
+    it("surfaces cause name when present", () => {
+        const cause = new TypeError("inner");
+        const outer = new Error("outer");
+        (outer as unknown as { cause: unknown }).cause = cause;
+        const desc = describeError(outer);
+        expect(desc.causeName).toBe("TypeError");
+        expect(desc.brief).toContain("cause=TypeError");
+    });
+
+    it("clips very long messages in brief", () => {
+        const long = "x".repeat(1000);
+        const err = new Error(long);
+        const desc = describeError(err);
+        expect(desc.brief.length).toBeLessThan(500);
+    });
+
+    it("getErrorMessage still works as before", () => {
+        expect(getErrorMessage(new Error("foo"))).toBe("foo");
+        expect(getErrorMessage("bar")).toBe("bar");
+    });
+});

package/src/shared/error-message.ts

@@ -1,3 +1,115 @@
 export function getErrorMessage(error: unknown): string {
     return error instanceof Error ? error.message : String(error);
 }
+
+/**
+ * Produce a rich, safe-to-log description of any thrown value.
+ *
+ * Motivated by SDK errors whose `.message` is empty while `.name`/`toString()`
+ * carry the actual signal (e.g. `NotFoundError` with no message on OpenCode
+ * session-delete races). Using {@link getErrorMessage} alone erases that signal.
+ *
+ * Captures:
+ * - `name` from the Error (defaults to `constructor.name`)
+ * - `message` (may be empty)
+ * - first few stack frames
+ * - `String(error)` so objects and custom toString surfaces are visible
+ * - Common HTTP-shape fields (`status`, `statusCode`, `code`)
+ * - `cause` chain summary (first level only)
+ *
+ * Returns a compact, single-line-friendly string suitable for log lines,
+ * plus a structured object for callers that want individual fields.
+ */
+export interface ErrorDescription {
+    name: string;
+    message: string;
+    status?: string;
+    code?: string;
+    causeName?: string;
+    stackHead?: string;
+    stringForm: string;
+    /** Best short summary for human-readable logs. Never empty. */
+    brief: string;
+}
+
+function readString(value: unknown): string | undefined {
+    if (typeof value === "string" && value.length > 0) return value;
+    if (typeof value === "number") return String(value);
+    return undefined;
+}
+
+function clip(value: string, max: number): string {
+    if (value.length <= max) return value;
+    return `${value.slice(0, max)}…`;
+}
+
+export function describeError(error: unknown): ErrorDescription {
+    const stringForm = clip(safeString(error), 400);
+
+    if (!(error instanceof Error) && !(error && typeof error === "object")) {
+        return {
+            name: typeof error,
+            message: "",
+            stringForm,
+            brief: stringForm || "<empty>",
+        };
+    }
+
+    const obj = error as Record<string, unknown>;
+    const nameFromField = readString(obj.name);
+    const nameFromCtor = error?.constructor?.name;
+    const name = nameFromField ?? nameFromCtor ?? "Error";
+
+    const message = readString(obj.message) ?? "";
+    const status = readString(obj.status) ?? readString(obj.statusCode);
+    const code = readString(obj.code);
+
+    let causeName: string | undefined;
+    const cause = obj.cause;
+    if (cause && typeof cause === "object") {
+        const causeRecord = cause as Record<string, unknown>;
+        causeName =
+            readString(causeRecord.name) ??
+            (cause as { constructor?: { name?: string } }).constructor?.name;
+    }
+
+    const stack = readString(obj.stack);
+    const stackHead = stack
+        ? stack
+              .split("\n")
+              .slice(0, 4)
+              .map((l) => l.trim())
+              .filter((l) => l.length > 0)
+              .join(" | ")
+        : undefined;
+
+    const briefParts: string[] = [];
+    if (name) briefParts.push(name);
+    if (message) briefParts.push(`message="${clip(message, 200)}"`);
+    if (status) briefParts.push(`status=${status}`);
+    if (code) briefParts.push(`code=${code}`);
+    if (causeName) briefParts.push(`cause=${causeName}`);
+    if (!message && stringForm && stringForm !== name) {
+        briefParts.push(`str="${clip(stringForm, 200)}"`);
+    }
+    const brief = briefParts.join(" ") || stringForm || name;
+
+    return {
+        name,
+        message,
+        ...(status ? { status } : {}),
+        ...(code ? { code } : {}),
+        ...(causeName ? { causeName } : {}),
+        ...(stackHead ? { stackHead } : {}),
+        stringForm,
+        brief,
+    };
+}
+
+function safeString(value: unknown): string {
+    try {
+        return String(value);
+    } catch {
+        return "<unstringifiable>";
+    }
+}