@infinityi/engine-lib 1.3.1 → 1.4.0

package/dist/session-stores/jsonl.d.ts

@@ -0,0 +1,26 @@
+import type { Message } from "../messages/types";
+import type { SessionState, SessionStore } from "../session/types";
+import type { SessionStoreCodec } from "./types";
+export interface FilesystemJsonlSessionStoreOptions {
+    readonly directory: string;
+    readonly codec?: SessionStoreCodec;
+}
+/** Append-only JSONL {@link SessionStore} backed by one file per session id. */
+export declare class FilesystemJsonlSessionStore implements SessionStore {
+    private readonly directory;
+    private readonly codec;
+    private readonly queues;
+    constructor(options: FilesystemJsonlSessionStoreOptions);
+    migrate(): Promise<void>;
+    load(id: string): Promise<SessionState | undefined>;
+    append(id: string, messages: readonly Message[]): Promise<void>;
+    save(state: SessionState): Promise<void>;
+    delete(id: string): Promise<void>;
+    compact(id?: string): Promise<void>;
+    private pathFor;
+    private waitForWrites;
+    private enqueue;
+    private appendRecord;
+    private replayFile;
+    private compactFile;
+}

package/dist/session-stores/redis.d.ts

@@ -0,0 +1,45 @@
+import type { Message } from "../messages/types";
+import type { SessionState, SessionStore } from "../session/types";
+import type { SessionStoreCodec } from "./types";
+export interface RedisSessionStoreTransaction {
+    del(...keys: string[]): RedisSessionStoreTransaction;
+    set(key: string, value: string): RedisSessionStoreTransaction;
+    rPush?(key: string, ...values: string[]): RedisSessionStoreTransaction;
+    rpush?(key: string, ...values: string[]): RedisSessionStoreTransaction;
+    exec(): Promise<unknown> | unknown;
+}
+export interface RedisSessionStoreClient {
+    get(key: string): Promise<string | null | undefined> | string | null | undefined;
+    set(key: string, value: string): Promise<unknown> | unknown;
+    del(...keys: string[]): Promise<unknown> | unknown;
+    lRange?(key: string, start: number, stop: number): Promise<string[]> | string[];
+    lrange?(key: string, start: number, stop: number): Promise<string[]> | string[];
+    rPush?(key: string, ...values: string[]): Promise<unknown> | unknown;
+    rpush?(key: string, ...values: string[]): Promise<unknown> | unknown;
+    multi?(): RedisSessionStoreTransaction;
+}
+export interface RedisSessionStoreOptions {
+    readonly client: RedisSessionStoreClient;
+    readonly keyPrefix?: string;
+    readonly codec?: SessionStoreCodec;
+}
+/** Redis-list-backed {@link SessionStore} using a structural Redis client. */
+export declare class RedisSessionStore implements SessionStore {
+    private readonly client;
+    private readonly keyPrefix;
+    private readonly codec;
+    constructor(options: RedisSessionStoreOptions);
+    migrate(): Promise<void>;
+    load(id: string): Promise<SessionState | undefined>;
+    append(id: string, messages: readonly Message[]): Promise<void>;
+    save(state: SessionState): Promise<void>;
+    delete(id: string): Promise<void>;
+    private transaction;
+    private lRange;
+    private rPush;
+    private idKey;
+    private messagesKey;
+    private metadataKey;
+    private existsKey;
+    private versionKey;
+}

package/dist/session-stores/types.d.ts

@@ -0,0 +1,45 @@
+import type { Message } from "../messages/types";
+import type { SessionState, SessionStore } from "../session/types";
+/** Encodes persisted session payloads. Wrap this to add encryption at rest. */
+export interface SessionStoreCodec {
+    encodeMessage(message: Message): Promise<string> | string;
+    decodeMessage(payload: string): Promise<Message> | Message;
+    encodeMetadata?(metadata: Readonly<Record<string, unknown>> | undefined): Promise<string | undefined> | string | undefined;
+    decodeMetadata?(payload: string | undefined): Promise<Readonly<Record<string, unknown>> | undefined> | Readonly<Record<string, unknown>> | undefined;
+}
+/** A store that can initialize or migrate its backing data format. */
+export interface VersionedSessionStore extends SessionStore {
+    migrate(): Promise<void>;
+}
+/** A store that owns resources that should be released at shutdown. */
+export interface CloseableSessionStore extends SessionStore {
+    close(): Promise<void>;
+}
+export type SessionStoreHookOperation = "append" | "save";
+export interface SessionStoreHookContext {
+    readonly operation: SessionStoreHookOperation;
+    readonly store: SessionStore;
+}
+export interface SessionArchiveRecord {
+    readonly id: string;
+    readonly at: string;
+    readonly operation: SessionStoreHookOperation;
+    readonly messages?: readonly Message[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly reason?: string;
+}
+export interface SessionCompactionResult {
+    readonly state: SessionState;
+    readonly archive?: Omit<SessionArchiveRecord, "id" | "at" | "operation">;
+}
+export interface SessionCompactor {
+    shouldCompact?(state: SessionState, context: SessionStoreHookContext): Promise<boolean> | boolean;
+    compact(state: SessionState, context: SessionStoreHookContext): Promise<SessionState | SessionCompactionResult> | SessionState | SessionCompactionResult;
+}
+export interface SessionArchiver {
+    archive(record: SessionArchiveRecord, context: SessionStoreHookContext): Promise<void> | void;
+}
+export interface SessionStoreHooks {
+    readonly compactor?: SessionCompactor;
+    readonly archiver?: SessionArchiver;
+}

package/dist/session-stores/versioning.d.ts

@@ -0,0 +1,6 @@
+import type { SessionStore } from "../session/types";
+import type { CloseableSessionStore, VersionedSessionStore } from "./types";
+export declare const SESSION_STORE_SCHEMA_VERSION = 1;
+export declare function isVersionedSessionStore(store: SessionStore): store is VersionedSessionStore;
+export declare function isCloseableSessionStore(store: SessionStore): store is CloseableSessionStore;
+export declare function migrateSessionStore(store: SessionStore): Promise<void>;

package/dist/testing/conformance.js

@@ -6,14 +6,15 @@ import"../index-vnby35rm.js";
 import"../index-19pwq79t.js";
 import {
   combine
-} from "../index-bqg01r42.js";
+} from "../index-zdggff0y.js";
 import"../index-zfgr4xx3.js";
-import {
-  ProviderError
-} from "../index-7690reng.js";
 import {
   user
 } from "../index-1p6mb2vz.js";
+import {
+  ProviderError
+} from "../index-ajr3nk10.js";
+import"../index-37x76zdn.js";
 
 // src/testing/conformance.ts
 function getTestApi() {

package/dist/testing/index.js

@@ -15,6 +15,7 @@ import {
   InMemorySessionStore
 } from "../index-vnby35rm.js";
 import"../index-zfgr4xx3.js";
+import"../index-37x76zdn.js";
 export {
   toolCallResult,
   textResult,

package/dist/tools/index.js

@@ -1,12 +1,14 @@
-import {
-  defineTool
-} from "../index-w34cbktd.js";
+import"../index-9rr5dkzh.js";
 import {
   renderToolContent,
   toProviderTool,
   toToolResultMessage
 } from "../index-rentvdpp.js";
 import"../index-1p6mb2vz.js";
+import {
+  defineTool
+} from "../index-a67ej96j.js";
+import"../index-37x76zdn.js";
 export {
   toToolResultMessage,
   toProviderTool,

package/dist/tools-fs/define.d.ts

@@ -0,0 +1,2 @@
+import type { FilesystemTools, FilesystemToolsConfig } from "./types";
+export declare function filesystemTools(config: FilesystemToolsConfig): FilesystemTools;

package/dist/tools-fs/files.d.ts

@@ -0,0 +1,40 @@
+export interface ListedEntry {
+    readonly path: string;
+    readonly relativePath: string;
+    readonly type: "file" | "directory" | "symlink" | "other";
+    readonly size: number;
+}
+export interface ListOptions {
+    readonly includeHidden?: boolean;
+    readonly respectGitignore?: boolean;
+    readonly includeFiles?: boolean;
+    readonly maxEntries?: number;
+    readonly onlyFiles?: boolean;
+    readonly includeGlobs?: readonly string[];
+    readonly excludeGlobs?: readonly string[];
+}
+export declare function fileVersion(bytes: string | Buffer): string;
+export declare function languageForPath(path: string): string | undefined;
+export declare function isProbablyTextPath(path: string): boolean;
+export declare function isHiddenRelativePath(path: string): boolean;
+export declare function listEntries(root: string, options?: ListOptions): Promise<{
+    readonly entries: ListedEntry[];
+    readonly truncated: boolean;
+    readonly total: number;
+}>;
+export declare function readTextFile(path: string, maxBytes: number): Promise<{
+    readonly text: string;
+    readonly version: string;
+    readonly truncated: boolean;
+}>;
+export declare function atomicWrite(path: string, content: string): Promise<string>;
+export declare function removeFile(path: string): Promise<void>;
+export declare function lineOffsets(text: string): readonly string[];
+export declare function renderLineRange(lines: readonly string[], startLine: number, endLine: number, includeLineNumbers: boolean): string;
+export declare function clampLineRange(totalLines: number, startLine?: number, endLine?: number): {
+    readonly startLine: number;
+    readonly endLine: number;
+};
+export declare function detectFrameworks(entries: readonly ListedEntry[]): string[];
+export declare function importantFiles(entries: readonly ListedEntry[]): string[];
+export declare function pathForDisplay(root: string, path: string): string;

package/dist/tools-fs/git.d.ts

@@ -0,0 +1,14 @@
+export declare function diffStatus(root: string, options: {
+    readonly paths?: readonly string[];
+    readonly includeDiff: boolean;
+    readonly maxDiffChars: number;
+    readonly contextLines: number;
+}): Promise<{
+    readonly isGitRepo: boolean;
+    readonly files: readonly {
+        readonly path: string;
+        readonly status: string;
+        readonly diff?: string;
+    }[];
+    readonly truncated: boolean;
+}>;

package/dist/tools-fs/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `@infinityi/engine-lib/tools-fs` — optional, policy-gated filesystem and
+ * workspace tools for coding agents and local document agents.
+ *
+ * The core library remains tool-agnostic. This subpath exports a single
+ * {@link filesystemTools} factory that binds prebuilt tool definitions to an
+ * explicit allowed-root policy.
+ *
+ * @example
+ * ```ts
+ * import { filesystemTools } from "@infinityi/engine-lib/tools-fs";
+ *
+ * const fs = filesystemTools({ allowedRoots: [process.cwd()] });
+ * ```
+ *
+ * @module
+ */
+export { filesystemTools } from "./define";
+export type { ApplyPatchArgs, DiffStatusArgs, EditRangeArgs, EditReplaceArgs, FilesystemTools, FilesystemToolsConfig, FindFilesArgs, OpenWindowArgs, ReadArgs, RepoMapArgs, SearchSemanticArgs, SearchTextArgs, SymbolInfo, SymbolKind, SymbolsArgs, ValidationCommandRequest, ValidationCommandResult, ValidationOptions, WriteFileArgs, } from "./types";