opencode-graphiti 0.0.0-development

package/esm/src/services/graphiti-async.d.ts

@@ -0,0 +1,22 @@
+import type { BatchDrainService } from "./batch-drain.js";
+import type { GraphitiMcpClient } from "./graphiti-mcp.js";
+import type { RedisCacheService } from "./redis-cache.js";
+export declare class GraphitiAsyncService {
+    private readonly graphiti;
+    private readonly cache;
+    private readonly drain;
+    private readonly drainRetryDelayMs;
+    private readonly drainInFlight;
+    private readonly drainRetryTimers;
+    private readonly drainRecoveryTimers;
+    private readonly refreshInFlight;
+    private readonly primerInFlight;
+    constructor(graphiti: GraphitiMcpClient, cache: RedisCacheService, drain: BatchDrainService, drainRetryDelayMs?: number);
+    private armDrainRetry;
+    private armDrainRecovery;
+    private clearDrainRecovery;
+    schedulePrimer(groupId: string): void;
+    scheduleCacheRefresh(groupId: string, query: string): void;
+    scheduleDrain(groupId: string): void;
+}
+//# sourceMappingURL=graphiti-async.d.ts.map

package/esm/src/services/graphiti-async.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphiti-async.d.ts","sourceRoot":"","sources":["../../../src/src/services/graphiti-async.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAC1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAE3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAE1D,qBAAa,oBAAoB;IAiB7B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAnBpC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAoC;IAClE,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAG7B;IACJ,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAMhC;IACJ,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAoC;IACpE,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAoC;gBAGhD,QAAQ,EAAE,iBAAiB,EAC3B,KAAK,EAAE,iBAAiB,EACxB,KAAK,EAAE,iBAAiB,EACxB,iBAAiB,SAAQ;IAG5C,OAAO,CAAC,aAAa;IASrB,OAAO,CAAC,gBAAgB;IAiBxB,OAAO,CAAC,kBAAkB;IAO1B,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAuBrC,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAuE1D,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;CA2CrC"}

package/esm/src/services/graphiti-async.js

@@ -0,0 +1,219 @@
+import { logger } from "./logger.js";
+export class GraphitiAsyncService {
+    constructor(graphiti, cache, drain, drainRetryDelayMs = 1_000) {
+        Object.defineProperty(this, "graphiti", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: graphiti
+        });
+        Object.defineProperty(this, "cache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: cache
+        });
+        Object.defineProperty(this, "drain", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: drain
+        });
+        Object.defineProperty(this, "drainRetryDelayMs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: drainRetryDelayMs
+        });
+        Object.defineProperty(this, "drainInFlight", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "drainRetryTimers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "drainRecoveryTimers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "refreshInFlight", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "primerInFlight", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    armDrainRetry(groupId) {
+        if (this.drainRetryTimers.has(groupId))
+            return;
+        const timer = setTimeout(() => {
+            this.drainRetryTimers.delete(groupId);
+            this.scheduleDrain(groupId);
+        }, this.drainRetryDelayMs);
+        this.drainRetryTimers.set(groupId, timer);
+    }
+    armDrainRecovery(groupId, run) {
+        const existing = this.drainRecoveryTimers.get(groupId);
+        if (existing?.run === run)
+            return;
+        if (existing)
+            clearTimeout(existing.timer);
+        const timer = setTimeout(() => {
+            const recovery = this.drainRecoveryTimers.get(groupId);
+            if (!recovery || recovery.run !== run)
+                return;
+            this.drainRecoveryTimers.delete(groupId);
+            if (this.drainInFlight.get(groupId) !== run)
+                return;
+            this.drainInFlight.delete(groupId);
+            this.scheduleDrain(groupId);
+        }, this.drainRetryDelayMs);
+        this.drainRecoveryTimers.set(groupId, { run, timer });
+    }
+    clearDrainRecovery(groupId, run) {
+        const recovery = this.drainRecoveryTimers.get(groupId);
+        if (!recovery || recovery.run !== run)
+            return;
+        clearTimeout(recovery.timer);
+        this.drainRecoveryTimers.delete(groupId);
+    }
+    schedulePrimer(groupId) {
+        if (this.primerInFlight.has(groupId))
+            return;
+        const run = (async () => {
+            const existing = await this.cache.get(groupId);
+            if (existing)
+                return;
+            const episodes = await this.graphiti.getEpisodes({ groupId, lastN: 5 });
+            if (episodes.length === 0)
+                return;
+            const entry = {
+                query: "primer",
+                refreshedAt: Date.now(),
+                nodes: [],
+                nodeRefs: [],
+                episodeSummaries: episodes.map((episode) => `${episode.name}: ${episode.content}`.slice(0, 240)),
+            };
+            await this.cache.set(groupId, entry);
+        })().catch((err) => logger.warn("Graphiti primer failed", err)).finally(() => this.primerInFlight.delete(groupId));
+        this.primerInFlight.set(groupId, run);
+    }
+    scheduleCacheRefresh(groupId, query) {
+        const normalized = query.trim();
+        if (!normalized)
+            return;
+        const key = groupId;
+        if (this.refreshInFlight.has(key)) {
+            void this.cache.rememberRefreshQuery(groupId, normalized).catch((err) => logger.warn("Graphiti refresh query update failed", err));
+            return;
+        }
+        const run = (async () => {
+            await this.cache.rememberRefreshQuery(groupId, normalized);
+            const [facts, result] = await Promise.all([
+                this.graphiti.searchMemoryFacts({
+                    query: normalized,
+                    groupIds: [groupId],
+                    maxFacts: 8,
+                }),
+                this.graphiti.searchNodesWithStatus({
+                    query: normalized,
+                    groupIds: [groupId],
+                    maxNodes: 12,
+                }),
+            ]);
+            if (result.degraded)
+                return;
+            const [meta, current] = await Promise.all([
+                this.cache.getMeta(groupId),
+                this.cache.get(groupId),
+            ]);
+            const latestQuery = meta?.lastQuery ?? current?.query;
+            if (latestQuery &&
+                latestQuery.trim().toLowerCase() !== normalized.toLowerCase()) {
+                return;
+            }
+            const { nodes } = result;
+            await this.cache.set(groupId, {
+                query: normalized,
+                refreshedAt: Date.now(),
+                nodes,
+                episodeSummaries: facts.map((fact) => {
+                    const source = fact.source_node?.name?.trim();
+                    const target = fact.target_node?.name?.trim();
+                    const relation = [source, target].filter(Boolean).join(" → ");
+                    return relation ? `${relation}: ${fact.fact}` : fact.fact;
+                }),
+                nodeRefs: nodes.map((node) => node.uuid),
+            });
+        })().catch((err) => logger.warn("Graphiti cache refresh failed", err))
+            .finally(async () => {
+            this.refreshInFlight.delete(key);
+            try {
+                const latestQuery = (await this.cache.getMeta(groupId))?.lastQuery;
+                if (latestQuery &&
+                    latestQuery.trim().toLowerCase() !== normalized.toLowerCase()) {
+                    this.scheduleCacheRefresh(groupId, latestQuery);
+                }
+            }
+            catch (err) {
+                logger.warn("Graphiti follow-up cache refresh failed", err);
+            }
+        });
+        this.refreshInFlight.set(key, run);
+    }
+    scheduleDrain(groupId) {
+        const inFlight = this.drainInFlight.get(groupId);
+        if (inFlight) {
+            this.armDrainRecovery(groupId, inFlight);
+            return;
+        }
+        const retryTimer = this.drainRetryTimers.get(groupId);
+        if (retryTimer) {
+            clearTimeout(retryTimer);
+            this.drainRetryTimers.delete(groupId);
+        }
+        const run = (async () => {
+            let shouldRefresh = false;
+            while (true) {
+                const result = await this.drain.drainGroup(groupId, this.graphiti);
+                if (result.status === "success" || result.status === "dead-letter") {
+                    shouldRefresh = true;
+                    continue;
+                }
+                if (result.status === "backoff" || result.status === "retry") {
+                    this.armDrainRetry(groupId);
+                }
+                break;
+            }
+            if (shouldRefresh) {
+                const [current, meta] = await Promise.all([
+                    this.cache.get(groupId),
+                    this.cache.getMeta(groupId),
+                ]);
+                const refreshQuery = meta?.lastQuery || current?.query;
+                if (refreshQuery)
+                    this.scheduleCacheRefresh(groupId, refreshQuery);
+            }
+        })().catch((err) => logger.warn("Graphiti drain failed", err)).finally(() => {
+            this.clearDrainRecovery(groupId, run);
+            if (this.drainInFlight.get(groupId) === run) {
+                this.drainInFlight.delete(groupId);
+            }
+        });
+        this.drainInFlight.set(groupId, run);
+        this.armDrainRecovery(groupId, run);
+    }
+}

package/esm/src/services/graphiti-mcp.d.ts

@@ -0,0 +1,57 @@
+import { type GraphitiToolCaller } from "./connection-manager.js";
+import type { GraphitiEpisode, GraphitiFact, GraphitiNode } from "../types/index.js";
+export type GraphitiNodeSearchResult = {
+    nodes: GraphitiNode[];
+    degraded: boolean;
+};
+export declare class GraphitiMcpClient {
+    private readonly toolCaller;
+    constructor(endpointOrManager: string | GraphitiToolCaller);
+    start(): void;
+    stop(): Promise<void>;
+    connect(): Promise<boolean>;
+    ready(timeoutMs?: number): Promise<boolean>;
+    parseToolResult(result: unknown): unknown;
+    parseWrappedArray<T>(result: unknown, wrappedKey: string): T[] | null;
+    addMemory(params: {
+        name: string;
+        episodeBody: string;
+        groupId?: string;
+        source?: "text" | "json" | "message";
+        sourceDescription?: string;
+    }): Promise<void>;
+    addEpisode(params: {
+        name: string;
+        episodeBody: string;
+        groupId?: string;
+        source?: "text" | "json" | "message";
+        sourceDescription?: string;
+    }): Promise<void>;
+    searchMemoryFacts(params: {
+        query: string;
+        groupIds?: string[];
+        maxFacts?: number;
+    }): Promise<GraphitiFact[]>;
+    searchFacts(params: {
+        query: string;
+        groupIds?: string[];
+        maxFacts?: number;
+    }): Promise<GraphitiFact[]>;
+    searchNodes(params: {
+        query: string;
+        groupIds?: string[];
+        maxNodes?: number;
+    }): Promise<GraphitiNode[]>;
+    searchNodesWithStatus(params: {
+        query: string;
+        groupIds?: string[];
+        maxNodes?: number;
+    }): Promise<GraphitiNodeSearchResult>;
+    getEpisodes(params: {
+        groupId?: string;
+        lastN?: number;
+    }): Promise<GraphitiEpisode[]>;
+    getStatus(): Promise<boolean>;
+    private callTool;
+}
+//# sourceMappingURL=graphiti-mcp.d.ts.map

package/esm/src/services/graphiti-mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphiti-mcp.d.ts","sourceRoot":"","sources":["../../../src/src/services/graphiti-mcp.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,kBAAkB,EAIxB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EACV,eAAe,EACf,YAAY,EACZ,YAAY,EACb,MAAM,mBAAmB,CAAC;AAK3B,MAAM,MAAM,wBAAwB,GAAG;IACrC,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAqB;gBAEpC,iBAAiB,EAAE,MAAM,GAAG,kBAAkB;IAM1D,KAAK,IAAI,IAAI;IAIP,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;IAgB3B,KAAK,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAIjD,eAAe,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO;IAyBzC,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,GAAG,CAAC,EAAE,GAAG,IAAI;IAY/D,SAAS,CAAC,MAAM,EAAE;QACtB,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,EAAE,MAAM,CAAC;QACpB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;QACrC,iBAAiB,CAAC,EAAE,MAAM,CAAC;KAC5B,GAAG,OAAO,CAAC,IAAI,CAAC;IA4BX,UAAU,CAAC,MAAM,EAAE;QACvB,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,EAAE,MAAM,CAAC;QACpB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;QACrC,iBAAiB,CAAC,EAAE,MAAM,CAAC;KAC5B,GAAG,OAAO,CAAC,IAAI,CAAC;IAIX,iBAAiB,CAAC,MAAM,EAAE;QAC9B,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IA6BrB,WAAW,CAAC,MAAM,EAAE;QACxB,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IAIrB,WAAW,CAAC,MAAM,EAAE;QACxB,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IAKrB,qBAAqB,CAAC,MAAM,EAAE;QAClC,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GAAG,OAAO,CAAC,wBAAwB,CAAC;IAgC/B,WAAW,CAAC,MAAM,EAAE;QACxB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IA8BxB,SAAS,IAAI,OAAO,CAAC,OAAO,CAAC;YASrB,QAAQ;CAOvB"}

package/esm/src/services/graphiti-mcp.js

@@ -0,0 +1,194 @@
+import { GraphitiConnectionManager, GraphitiOfflineError, GraphitiSessionExpiredError, GraphitiTransportError, isGraphitiOfflineError, isGraphitiTimeoutError, } from "./connection-manager.js";
+import { logger } from "./logger.js";
+import { notifyGraphitiAvailabilityIssue } from "./opencode-warning.js";
+import { normalizeEpisode } from "./sdk-normalize.js";
+export class GraphitiMcpClient {
+    constructor(endpointOrManager) {
+        Object.defineProperty(this, "toolCaller", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.toolCaller = typeof endpointOrManager === "string"
+            ? new GraphitiConnectionManager({ endpoint: endpointOrManager })
+            : endpointOrManager;
+    }
+    start() {
+        this.toolCaller.start();
+    }
+    async stop() {
+        await this.toolCaller.stop();
+    }
+    async connect() {
+        try {
+            this.toolCaller.start();
+        }
+        catch (err) {
+            if (isGraphitiOfflineError(err)) {
+                throw new GraphitiOfflineError(err.state, err.message ||
+                    "Graphiti client has been stopped and cannot be restarted");
+            }
+            throw err;
+        }
+        return await this.toolCaller.ready();
+    }
+    async ready(timeoutMs) {
+        return await this.toolCaller.ready(timeoutMs);
+    }
+    parseToolResult(result) {
+        const typedResult = result;
+        const content = typedResult.content;
+        if (!Array.isArray(content) || content.length === 0)
+            return result;
+        const text = content.find((item) => item?.type === "text")?.text;
+        if (text === undefined)
+            return result;
+        if (typeof text !== "string") {
+            try {
+                return JSON.parse(String(text));
+            }
+            catch {
+                return text;
+            }
+        }
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return text;
+        }
+    }
+    parseWrappedArray(result, wrappedKey) {
+        if (Array.isArray(result))
+            return result;
+        if (result &&
+            typeof result === "object" &&
+            Array.isArray(result[wrappedKey])) {
+            return result[wrappedKey];
+        }
+        return null;
+    }
+    async addMemory(params) {
+        try {
+            await this.callTool("add_memory", {
+                name: params.name,
+                episode_body: params.episodeBody,
+                group_id: params.groupId,
+                source: params.source ?? "text",
+                source_description: params.sourceDescription ?? "",
+            });
+        }
+        catch (err) {
+            if (isGraphitiOfflineError(err) ||
+                isGraphitiTimeoutError(err) ||
+                err instanceof GraphitiTransportError ||
+                err instanceof GraphitiSessionExpiredError) {
+                notifyGraphitiAvailabilityIssue("Graphiti unavailable; memory was not saved.", {
+                    operation: "addMemory",
+                    err,
+                });
+            }
+            throw err;
+        }
+    }
+    async addEpisode(params) {
+        await this.addMemory(params);
+    }
+    async searchMemoryFacts(params) {
+        try {
+            const result = await this.callTool("search_memory_facts", {
+                query: params.query,
+                group_ids: params.groupIds,
+                max_facts: params.maxFacts ?? 10,
+            });
+            return this.parseWrappedArray(result, "facts") ?? [];
+        }
+        catch (err) {
+            if (isGraphitiTimeoutError(err) ||
+                isGraphitiOfflineError(err) ||
+                err instanceof GraphitiTransportError ||
+                err instanceof GraphitiSessionExpiredError) {
+                notifyGraphitiAvailabilityIssue("Graphiti unavailable; continuing without memory facts.", {
+                    operation: "searchMemoryFacts",
+                    err,
+                });
+                return [];
+            }
+            logger.error("searchMemoryFacts error", err);
+            return [];
+        }
+    }
+    async searchFacts(params) {
+        return await this.searchMemoryFacts(params);
+    }
+    async searchNodes(params) {
+        const result = await this.searchNodesWithStatus(params);
+        return result.nodes;
+    }
+    async searchNodesWithStatus(params) {
+        try {
+            const result = await this.callTool("search_nodes", {
+                query: params.query,
+                group_ids: params.groupIds,
+                max_nodes: params.maxNodes ?? 10,
+            });
+            return {
+                nodes: this.parseWrappedArray(result, "nodes") ?? [],
+                degraded: false,
+            };
+        }
+        catch (err) {
+            if (isGraphitiTimeoutError(err) ||
+                isGraphitiOfflineError(err) ||
+                err instanceof GraphitiTransportError ||
+                err instanceof GraphitiSessionExpiredError) {
+                notifyGraphitiAvailabilityIssue("Graphiti unavailable; continuing without memory nodes.", {
+                    operation: "searchNodes",
+                    err,
+                });
+                return { nodes: [], degraded: true };
+            }
+            logger.error("searchNodes error", err);
+            return { nodes: [], degraded: true };
+        }
+    }
+    async getEpisodes(params) {
+        try {
+            const result = await this.callTool("get_episodes", {
+                group_id: params.groupId,
+                last_n: params.lastN,
+            });
+            const raw = this.parseWrappedArray(result, "episodes") ??
+                [];
+            return raw.map(normalizeEpisode);
+        }
+        catch (err) {
+            if (isGraphitiTimeoutError(err) ||
+                isGraphitiOfflineError(err) ||
+                err instanceof GraphitiTransportError ||
+                err instanceof GraphitiSessionExpiredError) {
+                notifyGraphitiAvailabilityIssue("Graphiti unavailable; continuing without episode history.", {
+                    operation: "getEpisodes",
+                    err,
+                });
+                return [];
+            }
+            logger.error("getEpisodes error", err);
+            return [];
+        }
+    }
+    async getStatus() {
+        try {
+            await this.callTool("get_status", {});
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async callTool(name, args) {
+        const result = await this.toolCaller.callTool(name, args);
+        return this.parseToolResult(result);
+    }
+}

package/esm/src/services/logger.d.ts

@@ -0,0 +1,9 @@
+export declare const setLoggerDebugOverride: (value: boolean | undefined) => void;
+export declare const setLoggerSilentOverride: (value: boolean) => void;
+export declare const logger: {
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+    debug: (...args: unknown[]) => void;
+};
+//# sourceMappingURL=logger.d.ts.map

package/esm/src/services/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/src/services/logger.ts"],"names":[],"mappings":"AA2EA,eAAO,MAAM,sBAAsB,GAAI,OAAO,OAAO,GAAG,SAAS,KAAG,IAEnE,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,OAAO,OAAO,KAAG,IAExD,CAAC;AAEF,eAAO,MAAM,MAAM;oBACD,OAAO,EAAE;oBAIT,OAAO,EAAE;qBAWR,OAAO,EAAE;qBAIT,OAAO,EAAE;CAI3B,CAAC"}

package/esm/src/services/logger.js

@@ -0,0 +1,104 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { logStructuredWarning, shouldSuppressConsoleWarningsDuringTests, } from "./opencode-warning.js";
+const console = globalThis.console;
+const PREFIX = "[graphiti]";
+let debugOverride;
+let silentOverride = false;
+const serializeLogArg = (value) => {
+    if (value instanceof Error) {
+        return {
+            name: value.name,
+            message: value.message,
+            stack: value.stack,
+        };
+    }
+    return value;
+};
+const stringifyLogArg = (value) => {
+    if (typeof value === "string")
+        return value;
+    if (value instanceof Error)
+        return value.message;
+    if (typeof value === "number" || typeof value === "boolean" ||
+        typeof value === "bigint") {
+        return String(value);
+    }
+    if (value === null)
+        return "null";
+    if (value === undefined)
+        return "undefined";
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+};
+const toWarningPayload = (args) => {
+    if (args.length === 0)
+        return { message: "Graphiti warning" };
+    const [first, ...rest] = args;
+    if (typeof first === "string") {
+        return rest.length === 0
+            ? { message: first }
+            : { message: first, extra: { data: rest.map(serializeLogArg) } };
+    }
+    return {
+        message: stringifyLogArg(first),
+        ...(rest.length === 0 ? {} : {
+            extra: {
+                data: [serializeLogArg(first), ...rest.map(serializeLogArg)],
+            },
+        }),
+    };
+};
+const isDebugEnabled = () => {
+    if (debugOverride !== undefined)
+        return debugOverride;
+    try {
+        return !!dntShim.Deno.env.get("GRAPHITI_DEBUG");
+    }
+    catch {
+        return false;
+    }
+};
+export const setLoggerDebugOverride = (value) => {
+    debugOverride = value;
+};
+export const setLoggerSilentOverride = (value) => {
+    silentOverride = value;
+};
+export const logger = {
+    info: (...args) => {
+        if (silentOverride)
+            return;
+        if (isDebugEnabled())
+            console.log(PREFIX, ...args);
+    },
+    warn: (...args) => {
+        if (silentOverride)
+            return;
+        const payload = toWarningPayload(args);
+        try {
+            if (logStructuredWarning(payload.message, payload.extra))
+                return;
+        }
+        catch {
+            // Fall back to console below when structured warning scheduling fails.
+        }
+        if (shouldSuppressConsoleWarningsDuringTests())
+            return;
+        console.warn(PREFIX, ...args);
+    },
+    error: (...args) => {
+        if (silentOverride)
+            return;
+        console.error(PREFIX, ...args);
+    },
+    debug: (...args) => {
+        if (silentOverride)
+            return;
+        if (isDebugEnabled())
+            console.debug(PREFIX, ...args);
+    },
+};

package/esm/src/services/opencode-warning.d.ts

@@ -0,0 +1,8 @@
+export declare const shouldSuppressConsoleWarningsDuringTests: () => boolean;
+export declare const setOpenCodeClient: (client: unknown) => void;
+export declare const setWarningTaskScheduler: (scheduler: ((callback: () => void) => void) | undefined) => void;
+export declare const setSuppressConsoleWarningsDuringTestsOverride: (value: boolean | undefined) => void;
+export declare const logStructuredWarning: (message: string, extra?: unknown) => boolean;
+export declare const showWarningToast: (message: string, extra?: unknown) => boolean;
+export declare const notifyGraphitiAvailabilityIssue: (message: string, extra?: unknown) => void;
+//# sourceMappingURL=opencode-warning.d.ts.map

package/esm/src/services/opencode-warning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opencode-warning.d.ts","sourceRoot":"","sources":["../../../src/src/services/opencode-warning.ts"],"names":[],"mappings":"AAoCA,eAAO,MAAM,wCAAwC,QAAO,OAM3D,CAAC;AA6FF,eAAO,MAAM,iBAAiB,GAC5B,QAAQ,OAAO,KACd,IAEF,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,WAAW,CAAC,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC,GAAG,SAAS,KACtD,IAIF,CAAC;AAEF,eAAO,MAAM,6CAA6C,GACxD,OAAO,OAAO,GAAG,SAAS,KACzB,IAEF,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,SAAS,MAAM,EACf,QAAQ,OAAO,KACd,OAEF,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,SAAS,MAAM,EAAE,QAAQ,OAAO,KAAG,OAEnE,CAAC;AAEF,eAAO,MAAM,+BAA+B,GAC1C,SAAS,MAAM,EACf,QAAQ,OAAO,KACd,IAMF,CAAC"}