@orion-agents/orion-code 0.1.3 → 0.1.4

package/dist/utils/debug-log.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Diagnostics boundary for intentionally-swallowed errors.
+ *
+ * A large part of the codebase deliberately tolerates failures: a missing
+ * config file, a non-git directory, a corrupt session record. The historical
+ * pattern for those paths was a parameterless `catch {}`, which discards the
+ * error object entirely. That is fine for control flow and catastrophic for
+ * diagnosis — once the exception is gone there is nothing left to explain why
+ * a session failed to persist or why a provider silently fell back.
+ *
+ * `debugError` keeps the tolerant behaviour but preserves the signal: the
+ * error is routed to stderr only when the user opts in via `ORION_CODE_DEBUG`.
+ * Default runs stay completely silent, so the TUI is never polluted.
+ *
+ * Usage:
+ *
+ * ```ts
+ * try {
+ *   writeFileSync(path, data);
+ * } catch (error) {
+ *   debugError('session-storage.save', error, path);
+ * }
+ * ```
+ */
+/** Environment variable that opts into diagnostic output. */
+export declare const DEBUG_ENV_VAR = "ORION_CODE_DEBUG";
+/**
+ * Whether diagnostics are enabled.
+ *
+ * Read on every call (not cached) so tests and long-lived processes can flip
+ * the flag at runtime.
+ */
+export declare function isDebugEnabled(): boolean;
+/**
+ * Render an unknown thrown value as a single-line, human-readable string.
+ *
+ * `catch` can receive anything, not just `Error`, so this normalises strings,
+ * plain objects and `undefined` instead of printing `[object Object]`.
+ */
+export declare function formatError(error: unknown): string;
+/**
+ * Report a swallowed error.
+ *
+ * No-op unless `ORION_CODE_DEBUG` is set, and never throws — a diagnostics
+ * helper must not be able to break the path it is instrumenting.
+ *
+ * @param scope   Dotted identifier of the call site, e.g. `auth.load`.
+ * @param error   The caught value.
+ * @param detail  Optional extra context (a path, an id, a provider name).
+ */
+export declare function debugError(scope: string, error: unknown, detail?: string): void;
+//# sourceMappingURL=debug-log.d.ts.map

package/dist/utils/debug-log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug-log.d.ts","sourceRoot":"","sources":["../../src/utils/debug-log.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,6DAA6D;AAC7D,eAAO,MAAM,aAAa,qBAAqB,CAAC;AAKhD;;;;;GAKG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAGxC;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAalD;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAU/E"}

package/dist/utils/debug-log.js

@@ -0,0 +1,91 @@
+"use strict";
+/**
+ * Diagnostics boundary for intentionally-swallowed errors.
+ *
+ * A large part of the codebase deliberately tolerates failures: a missing
+ * config file, a non-git directory, a corrupt session record. The historical
+ * pattern for those paths was a parameterless `catch {}`, which discards the
+ * error object entirely. That is fine for control flow and catastrophic for
+ * diagnosis — once the exception is gone there is nothing left to explain why
+ * a session failed to persist or why a provider silently fell back.
+ *
+ * `debugError` keeps the tolerant behaviour but preserves the signal: the
+ * error is routed to stderr only when the user opts in via `ORION_CODE_DEBUG`.
+ * Default runs stay completely silent, so the TUI is never polluted.
+ *
+ * Usage:
+ *
+ * ```ts
+ * try {
+ *   writeFileSync(path, data);
+ * } catch (error) {
+ *   debugError('session-storage.save', error, path);
+ * }
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEBUG_ENV_VAR = void 0;
+exports.isDebugEnabled = isDebugEnabled;
+exports.formatError = formatError;
+exports.debugError = debugError;
+/** Environment variable that opts into diagnostic output. */
+exports.DEBUG_ENV_VAR = 'ORION_CODE_DEBUG';
+/** Prefix used for every diagnostic line so output is greppable. */
+const LOG_PREFIX = '[orion:debug]';
+/**
+ * Whether diagnostics are enabled.
+ *
+ * Read on every call (not cached) so tests and long-lived processes can flip
+ * the flag at runtime.
+ */
+function isDebugEnabled() {
+    const value = process.env[exports.DEBUG_ENV_VAR];
+    return value === '1' || value === 'true';
+}
+/**
+ * Render an unknown thrown value as a single-line, human-readable string.
+ *
+ * `catch` can receive anything, not just `Error`, so this normalises strings,
+ * plain objects and `undefined` instead of printing `[object Object]`.
+ */
+function formatError(error) {
+    if (error instanceof Error) {
+        return error.stack ? error.stack.split('\n').slice(0, 3).join(' | ') : error.message;
+    }
+    if (typeof error === 'string')
+        return error;
+    if (error === undefined)
+        return '(no error value)';
+    try {
+        return JSON.stringify(error) ?? String(error);
+    }
+    catch {
+        // The value is not serialisable (cycles, getters that throw); its string
+        // form is the best remaining signal and cannot itself fail here.
+        return String(error);
+    }
+}
+/**
+ * Report a swallowed error.
+ *
+ * No-op unless `ORION_CODE_DEBUG` is set, and never throws — a diagnostics
+ * helper must not be able to break the path it is instrumenting.
+ *
+ * @param scope   Dotted identifier of the call site, e.g. `auth.load`.
+ * @param error   The caught value.
+ * @param detail  Optional extra context (a path, an id, a provider name).
+ */
+function debugError(scope, error, detail) {
+    if (!isDebugEnabled())
+        return;
+    try {
+        const suffix = detail ? ` [${detail}]` : '';
+        console.error(`${LOG_PREFIX} ${scope}${suffix}: ${formatError(error)}`);
+    }
+    catch {
+        // Writing diagnostics must never escalate into a real failure (closed
+        // stderr, EPIPE on a killed pager). Dropping the line is the correct
+        // outcome here — there is nowhere left to report it to.
+    }
+}
+//# sourceMappingURL=debug-log.js.map

package/dist/utils/debug-log.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug-log.js","sourceRoot":"","sources":["../../src/utils/debug-log.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;;;AAcH,wCAGC;AAQD,kCAaC;AAYD,gCAUC;AA1DD,6DAA6D;AAChD,QAAA,aAAa,GAAG,kBAAkB,CAAC;AAEhD,oEAAoE;AACpE,MAAM,UAAU,GAAG,eAAe,CAAC;AAEnC;;;;;GAKG;AACH,SAAgB,cAAc;IAC5B,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,qBAAa,CAAC,CAAC;IACzC,OAAO,KAAK,KAAK,GAAG,IAAI,KAAK,KAAK,MAAM,CAAC;AAC3C,CAAC;AAED;;;;;GAKG;AACH,SAAgB,WAAW,CAAC,KAAc;IACxC,IAAI,KAAK,YAAY,KAAK,EAAE,CAAC;QAC3B,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC;IACvF,CAAC;IACD,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IAC5C,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,kBAAkB,CAAC;IACnD,IAAI,CAAC;QACH,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC;IAChD,CAAC;IAAC,MAAM,CAAC;QACP,yEAAyE;QACzE,iEAAiE;QACjE,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;IACvB,CAAC;AACH,CAAC;AAED;;;;;;;;;GASG;AACH,SAAgB,UAAU,CAAC,KAAa,EAAE,KAAc,EAAE,MAAe;IACvE,IAAI,CAAC,cAAc,EAAE;QAAE,OAAO;IAC9B,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,KAAK,MAAM,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;QAC5C,OAAO,CAAC,KAAK,CAAC,GAAG,UAAU,IAAI,KAAK,GAAG,MAAM,KAAK,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IAC1E,CAAC;IAAC,MAAM,CAAC;QACP,sEAAsE;QACtE,qEAAqE;QACrE,wDAAwD;IAC1D,CAAC;AACH,CAAC"}

package/dist/utils/errors.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Helpers for reading a caught value safely.
+ *
+ * TypeScript types `catch` bindings as `unknown`, and the codebase used to
+ * work around that by writing `catch (err: any)` and reaching for
+ * `err.message`. That silently produces the string `"undefined"` whenever
+ * something other than an `Error` is thrown — a rejected promise carrying a
+ * string, an axios object, a `throw { code }` — which is exactly when a clear
+ * message matters most.
+ */
+/**
+ * Extract a human-readable message from any thrown value.
+ *
+ * - `Error`            -> `error.message`
+ * - `string`           -> the string itself
+ * - `{ message: '…' }` -> that message (axios/node-fetch style error objects)
+ * - anything else      -> `String(value)`
+ */
+export declare function errorMessage(error: unknown): string;
+/**
+ * Read the `code` property that Node's `ErrnoException` and most HTTP clients
+ * attach (`ENOENT`, `EACCES`, `ECONNREFUSED`, …), without asserting a type.
+ */
+export declare function errorCode(error: unknown): string | undefined;
+//# sourceMappingURL=errors.d.ts.map

package/dist/utils/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/utils/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAQnD;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAM5D"}

package/dist/utils/errors.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * Helpers for reading a caught value safely.
+ *
+ * TypeScript types `catch` bindings as `unknown`, and the codebase used to
+ * work around that by writing `catch (err: any)` and reaching for
+ * `err.message`. That silently produces the string `"undefined"` whenever
+ * something other than an `Error` is thrown — a rejected promise carrying a
+ * string, an axios object, a `throw { code }` — which is exactly when a clear
+ * message matters most.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorMessage = errorMessage;
+exports.errorCode = errorCode;
+/**
+ * Extract a human-readable message from any thrown value.
+ *
+ * - `Error`            -> `error.message`
+ * - `string`           -> the string itself
+ * - `{ message: '…' }` -> that message (axios/node-fetch style error objects)
+ * - anything else      -> `String(value)`
+ */
+function errorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === 'string')
+        return error;
+    if (typeof error === 'object' && error !== null) {
+        const message = error.message;
+        if (typeof message === 'string' && message)
+            return message;
+    }
+    return String(error);
+}
+/**
+ * Read the `code` property that Node's `ErrnoException` and most HTTP clients
+ * attach (`ENOENT`, `EACCES`, `ECONNREFUSED`, …), without asserting a type.
+ */
+function errorCode(error) {
+    if (typeof error === 'object' && error !== null) {
+        const code = error.code;
+        if (typeof code === 'string')
+            return code;
+    }
+    return undefined;
+}
+//# sourceMappingURL=errors.js.map

package/dist/utils/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/utils/errors.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;AAUH,oCAQC;AAMD,8BAMC;AA5BD;;;;;;;GAOG;AACH,SAAgB,YAAY,CAAC,KAAc;IACzC,IAAI,KAAK,YAAY,KAAK;QAAE,OAAO,KAAK,CAAC,OAAO,CAAC;IACjD,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IAC5C,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QAChD,MAAM,OAAO,GAAI,KAA+B,CAAC,OAAO,CAAC;QACzD,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO;YAAE,OAAO,OAAO,CAAC;IAC7D,CAAC;IACD,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;AACvB,CAAC;AAED;;;GAGG;AACH,SAAgB,SAAS,CAAC,KAAc;IACtC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QAChD,MAAM,IAAI,GAAI,KAA4B,CAAC,IAAI,CAAC;QAChD,IAAI,OAAO,IAAI,KAAK,QAAQ;YAAE,OAAO,IAAI,CAAC;IAC5C,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orion-agents/orion-code",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Orion Code - goal-driven coding agent for the terminal.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",