apunkt/trustgraph
1
0
Fork 0
mirror of https://github.com/trustgraph-ai/trustgraph.git synced 2026-07-01 09:29:38 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

chore(ts): consolidate effect native closeout

Browse source
This commit is contained in:
elpresidank 2026-06-11 08:34:59 -05:00
parent cd6c9107d7
commit fab718dce8
21 changed files with 199 additions and 3533 deletions
Download patch file Download diff file Expand all files Collapse all files

19
ts/packages/flow/src/config/service.ts
View file

@ -5,7 +5,7 @@
*/
import {NodeRuntime} from "@effect/platform-node";
import {Duration, Effect, HashMap, Match, Option, SynchronizedRef} from "effect";
import {Array as A, Duration, Effect, HashMap, Match, Option, Order, SynchronizedRef} from "effect";
import * as Predicate from "effect/Predicate";
import * as S from "effect/Schema";
import type {
@ -122,26 +122,27 @@ const initialState = (): ConfigServiceState => ({
const getHashMapValue = <K, V>(store: HashMap.HashMap<K, V>, key: K): V | undefined =>
Option.getOrUndefined(HashMap.get(store, key));
const compareText = (left: string, right: string): number =>
left.localeCompare(right);
const compareWorkspace = (left: string, right: string): number =>
const workspaceOrder = Order.make<string>((left, right) =>
left === right
? 0
: left === DEFAULT_WORKSPACE
? -1
: right === DEFAULT_WORKSPACE
? 1
: compareText(left, right);
: Order.String(left, right)
);
const orderByKey = <A>(order: Order.Order<string>): Order.Order<readonly [string, A]> =>
Order.mapInput(order, ([key]) => key);
const workspaceEntries = (store: ConfigStore): ReadonlyArray<readonly [string, WorkspaceStore]> =>
HashMap.toEntries(store).sort(([left], [right]) => compareWorkspace(left, right));
A.sort(HashMap.toEntries(store), orderByKey<WorkspaceStore>(workspaceOrder));
const namespaceEntries = (store: WorkspaceStore): ReadonlyArray<readonly [string, NamespaceStore]> =>
HashMap.toEntries(store).sort(([left], [right]) => compareText(left, right));
A.sort(HashMap.toEntries(store), orderByKey<NamespaceStore>(Order.String));
const valueEntries = (store: NamespaceStore): ReadonlyArray<readonly [string, unknown]> =>
HashMap.toEntries(store).sort(([left], [right]) => compareText(left, right));
A.sort(HashMap.toEntries(store), orderByKey<unknown>(Order.String));
const toPersistedWorkspaces = (
store: ConfigStore,

9
ts/packages/flow/src/cores/service.ts
View file

@ -29,7 +29,7 @@ import {
processorLifecycleError,
topics,
} from "@trustgraph/base";
import {Duration, Effect, HashMap, Match, SynchronizedRef} from "effect";
import {Array as A, Duration, Effect, HashMap, Match, Order, SynchronizedRef} from "effect";
import * as O from "effect/Option";
import * as S from "effect/Schema";
import {ensureDirectoryEffect, joinPath, readTextFileEffect, writeTextFileEffect} from "../runtime/effect-files.js";
@ -137,8 +137,11 @@ const cloneKnowledgeCore = (core: KnowledgeCore): KnowledgeCore => ({
})),
});
const sortedEntries = <A>(store: HashMap.HashMap<string, A>): ReadonlyArray<readonly [string, A]> =>
HashMap.toEntries(store).sort(([left], [right]) => left.localeCompare(right));
const sortedEntries = <Value>(store: HashMap.HashMap<string, Value>): ReadonlyArray<readonly [string, Value]> =>
A.sort(
HashMap.toEntries(store),
Order.make<readonly [string, Value]>(([left], [right]) => Order.String(left, right)),
);
const toPersistedSnapshot = (state: KnowledgeCoreServiceState): PersistedKnowledgeSnapshot => {
const kg: Record<string, KnowledgeCore> = {};

9
ts/packages/flow/src/flow-manager/service.ts
View file

@ -37,7 +37,7 @@ import {
import { makeProcessorProgram } from "@trustgraph/base";
import type { Message } from "@trustgraph/base";
import { NodeRuntime } from "@effect/platform-node";
import { Duration, Effect, HashMap, Match, Option, SynchronizedRef } from "effect";
import { Array as A, Duration, Effect, HashMap, Match, Option, Order, SynchronizedRef } from "effect";
import * as S from "effect/Schema";
// ---------- Internal state types ----------
@ -236,8 +236,11 @@ const isStringRecord = (value: unknown): value is Record<string, string> =>
const getHashMapValue = <K, V>(store: HashMap.HashMap<K, V>, key: K): V | undefined =>
Option.getOrUndefined(HashMap.get(store, key));
const sortedEntries = <A>(store: HashMap.HashMap<string, A>): ReadonlyArray<readonly [string, A]> =>
HashMap.toEntries(store).sort(([left], [right]) => left.localeCompare(right));
const sortedEntries = <Value>(store: HashMap.HashMap<string, Value>): ReadonlyArray<readonly [string, Value]> =>
A.sort(
HashMap.toEntries(store),
Order.make<readonly [string, Value]>(([left], [right]) => Order.String(left, right)),
);
const sortedKeys = <A>(store: HashMap.HashMap<string, A>): Array<string> =>
sortedEntries(store).map(([key]) => key);

4
ts/packages/flow/src/librarian/service.ts
View file

@ -35,7 +35,7 @@ import {
} from "@trustgraph/base";
import type { Message } from "@trustgraph/base";
import { NodeRuntime } from "@effect/platform-node";
import { Clock, Config, DateTime, Duration, Effect, Match, Option, Random, SynchronizedRef } from "effect";
import { Clock, Config, DateTime, Duration, Effect, Match, Option, Order, Random, SynchronizedRef } from "effect";
import * as A from "effect/Array";
import * as MutableHashMap from "effect/MutableHashMap";
import * as S from "effect/Schema";
@ -479,7 +479,7 @@ export function makeLibrarianService(config: LibrarianServiceConfig): LibrarianS
if (session === undefined) {
return yield* librarianServiceError("get-upload-status", `Upload not found: ${uploadId}`);
}
const receivedChunks = Array.from(MutableHashMap.keys(session.chunks)).sort((a, b) => a - b);
const receivedChunks = A.sort(Array.from(MutableHashMap.keys(session.chunks)), Order.Number);
const receivedSet = new Set(receivedChunks);
const missingChunks = Array.from({ length: session.totalChunks }, (_, i) => i).filter((i) => !receivedSet.has(i));
return {

8
ts/packages/flow/src/retrieval/graph-rag.ts
View file

@ -20,7 +20,7 @@ import type {
TriplesQueryResponse,
} from "@trustgraph/base";
import { Triple, errorMessage } from "@trustgraph/base";
import { Context, Effect, Layer, Match } from "effect";
import { Array as A, Context, Effect, Layer, Match, Order } from "effect";
import * as O from "effect/Option";
import * as S from "effect/Schema";
@ -348,8 +348,10 @@ const scoreEdges = Effect.fn("GraphRagEngine.scoreEdges")(function* (
yield* Effect.log(`[GraphRag] Edge scoring LLM response (first 500 chars): ${llmResp.response.slice(0, 500)}`);
const scored = parseScoredEdges(llmResp.response);
scored.sort((a, b) => b.score - a.score);
const scored = A.sort(
parseScoredEdges(llmResp.response),
Order.make<typeof ScoredEdge.Type>((left, right) => Order.Number(right.score, left.score)),
);
const topN = scored.slice(0, config.edgeLimit);
const result: Triple[] = [];