@aigne/afs-history 1.2.0-beta.4 → 1.2.0-beta.6

package/lib/cjs/storage/models/compact.d.ts

@@ -0,0 +1,183 @@
+import type { AFSModule } from "@aigne/afs";
+export declare const compactTableName: (module: AFSModule) => string;
+export declare const compactTable: (module: AFSModule) => import("@aigne/sqlite").SQLiteTableWithColumns<{
+    name: string;
+    schema: undefined;
+    columns: {
+        id: import("@aigne/sqlite").SQLiteColumn<{
+            name: "id";
+            tableName: string;
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        createdAt: import("@aigne/sqlite").SQLiteColumn<{
+            name: "createdAt";
+            tableName: string;
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            sqliteColumnBuilderBrand: "SQLiteCustomColumnBuilderBrand";
+        }>;
+        updatedAt: import("@aigne/sqlite").SQLiteColumn<{
+            name: "updatedAt";
+            tableName: string;
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            sqliteColumnBuilderBrand: "SQLiteCustomColumnBuilderBrand";
+        }>;
+        path: import("@aigne/sqlite").SQLiteColumn<{
+            name: "path";
+            tableName: string;
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        userId: import("@aigne/sqlite").SQLiteColumn<{
+            name: "userId";
+            tableName: string;
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        sessionId: import("@aigne/sqlite").SQLiteColumn<{
+            name: "sessionId";
+            tableName: string;
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        agentId: import("@aigne/sqlite").SQLiteColumn<{
+            name: "agentId";
+            tableName: string;
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        metadata: import("@aigne/sqlite").SQLiteColumn<{
+            name: string;
+            tableName: string;
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: {
+                scope?: string;
+                latestEntryId?: string;
+            } & Record<string, unknown>;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            sqliteColumnBuilderBrand: "SQLiteCustomColumnBuilderBrand";
+        }>;
+        content: import("@aigne/sqlite").SQLiteColumn<{
+            name: string;
+            tableName: string;
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: unknown;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            sqliteColumnBuilderBrand: "SQLiteCustomColumnBuilderBrand";
+        }>;
+    };
+    dialect: "sqlite";
+}>;

package/lib/cjs/storage/models/compact.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compactTable = exports.compactTableName = void 0;
+const sqlite_1 = require("@aigne/sqlite");
+const uuid_1 = require("@aigne/uuid");
+const compactTableName = (module) => `Entries_${module.name}_compact`;
+exports.compactTableName = compactTableName;
+const compactTable = (module) => (0, sqlite_1.sqliteTable)((0, exports.compactTableName)(module), {
+    id: (0, sqlite_1.text)("id")
+        .notNull()
+        .primaryKey()
+        .$defaultFn(() => (0, uuid_1.v7)()),
+    createdAt: (0, sqlite_1.datetime)("createdAt")
+        .notNull()
+        .$defaultFn(() => new Date()),
+    updatedAt: (0, sqlite_1.datetime)("updatedAt")
+        .notNull()
+        .$defaultFn(() => new Date())
+        .$onUpdateFn(() => new Date()),
+    path: (0, sqlite_1.text)("path").notNull(),
+    userId: (0, sqlite_1.text)("userId"),
+    sessionId: (0, sqlite_1.text)("sessionId"),
+    agentId: (0, sqlite_1.text)("agentId"),
+    metadata: (0, sqlite_1.json)("metadata"),
+    content: (0, sqlite_1.json)("content"),
+});
+exports.compactTable = compactTable;

package/lib/cjs/storage/models/memory.d.ts

@@ -0,0 +1,182 @@
+import type { AFSModule } from "@aigne/afs";
+export declare const memoryTableName: (module: AFSModule) => string;
+export declare const memoryTable: (module: AFSModule) => import("@aigne/sqlite").SQLiteTableWithColumns<{
+    name: string;
+    schema: undefined;
+    columns: {
+        id: import("@aigne/sqlite").SQLiteColumn<{
+            name: "id";
+            tableName: string;
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        createdAt: import("@aigne/sqlite").SQLiteColumn<{
+            name: "createdAt";
+            tableName: string;
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            sqliteColumnBuilderBrand: "SQLiteCustomColumnBuilderBrand";
+        }>;
+        updatedAt: import("@aigne/sqlite").SQLiteColumn<{
+            name: "updatedAt";
+            tableName: string;
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            sqliteColumnBuilderBrand: "SQLiteCustomColumnBuilderBrand";
+        }>;
+        path: import("@aigne/sqlite").SQLiteColumn<{
+            name: "path";
+            tableName: string;
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        userId: import("@aigne/sqlite").SQLiteColumn<{
+            name: "userId";
+            tableName: string;
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        sessionId: import("@aigne/sqlite").SQLiteColumn<{
+            name: "sessionId";
+            tableName: string;
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        agentId: import("@aigne/sqlite").SQLiteColumn<{
+            name: "agentId";
+            tableName: string;
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        metadata: import("@aigne/sqlite").SQLiteColumn<{
+            name: string;
+            tableName: string;
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: {
+                scope?: string;
+            } & Record<string, unknown>;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            sqliteColumnBuilderBrand: "SQLiteCustomColumnBuilderBrand";
+        }>;
+        content: import("@aigne/sqlite").SQLiteColumn<{
+            name: string;
+            tableName: string;
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: unknown;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            sqliteColumnBuilderBrand: "SQLiteCustomColumnBuilderBrand";
+        }>;
+    };
+    dialect: "sqlite";
+}>;

package/lib/cjs/storage/models/memory.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoryTable = exports.memoryTableName = void 0;
+const sqlite_1 = require("@aigne/sqlite");
+const uuid_1 = require("@aigne/uuid");
+const memoryTableName = (module) => `Entries_${module.name}_memory`;
+exports.memoryTableName = memoryTableName;
+const memoryTable = (module) => (0, sqlite_1.sqliteTable)((0, exports.memoryTableName)(module), {
+    id: (0, sqlite_1.text)("id")
+        .notNull()
+        .primaryKey()
+        .$defaultFn(() => (0, uuid_1.v7)()),
+    createdAt: (0, sqlite_1.datetime)("createdAt")
+        .notNull()
+        .$defaultFn(() => new Date()),
+    updatedAt: (0, sqlite_1.datetime)("updatedAt")
+        .notNull()
+        .$defaultFn(() => new Date())
+        .$onUpdateFn(() => new Date()),
+    path: (0, sqlite_1.text)("path").notNull(),
+    userId: (0, sqlite_1.text)("userId"),
+    sessionId: (0, sqlite_1.text)("sessionId"),
+    agentId: (0, sqlite_1.text)("agentId"),
+    metadata: (0, sqlite_1.json)("metadata"),
+    content: (0, sqlite_1.json)("content"),
+});
+exports.memoryTable = memoryTable;

package/lib/cjs/storage/type.d.ts

@@ -1,22 +1,49 @@
 import type { AFSEntry, AFSModule } from "@aigne/afs";
 import type { SQL } from "@aigne/sqlite";
-export interface AFSStorageCreatePayload extends Omit<AFSEntry, "id"> {
+export interface AFSStorageCreatePayload extends AFSEntry {
 }
-export interface AFSStorageListOptions {
+export interface AFSStorageTypeOptions {
+    type?: EntryType;
+    scope?: Scope;
+}
+export interface AFSStorageListOptions extends AFSStorageTypeOptions {
     filter?: {
         agentId?: string;
         userId?: string;
         sessionId?: string;
+        before?: Date | string;
+        after?: Date | string;
     };
     limit?: number;
     orderBy?: [string, "asc" | "desc"][];
 }
+export interface AFSStorageReadOptions extends AFSStorageTypeOptions {
+    filter?: {
+        agentId?: string;
+        userId?: string;
+        sessionId?: string;
+    };
+}
+export interface AFSStorageDeleteOptions extends AFSStorageTypeOptions {
+    filter?: {
+        agentId?: string;
+        userId?: string;
+        sessionId?: string;
+    };
+}
+export type EntryType = "history" | "compact" | "memory";
+export type Scope = "session" | "user" | "agent";
+export interface AFSStorageCreateOptions extends AFSStorageTypeOptions {
+}
 export interface AFSStorage {
-    create(entry: AFSStorageCreatePayload): Promise<AFSEntry>;
+    create(entry: AFSStorageCreatePayload, options?: AFSStorageCreateOptions): Promise<AFSEntry>;
     list(options?: AFSStorageListOptions): Promise<{
         data: AFSEntry[];
     }>;
-    read(path: string): Promise<AFSEntry | undefined>;
+    read(id: string, options?: AFSStorageReadOptions): Promise<AFSEntry | undefined>;
+    delete(id: string, options?: AFSStorageDeleteOptions): Promise<{
+        deletedCount: number;
+    }>;
 }
 export type AFSStorageMigrations = {
     hash: string;

package/lib/dts/index.d.ts

@@ -1,4 +1,4 @@
-import type { AFSListOptions, AFSListResult, AFSModule, AFSReadResult, AFSRoot } from "@aigne/afs";
+import type { AFSDeleteOptions, AFSDeleteResult, AFSListOptions, AFSListResult, AFSModule, AFSReadOptions, AFSReadResult, AFSRoot, AFSWriteEntryPayload, AFSWriteResult } from "@aigne/afs";
 import { SharedAFSStorage, type SharedAFSStorageOptions } from "./storage/index.js";
 export * from "./storage/index.js";
 export interface AFSHistoryOptions {
@@ -6,9 +6,15 @@ export interface AFSHistoryOptions {
 }
 export declare class AFSHistory implements AFSModule {
     constructor(options?: AFSHistoryOptions);
-    private storage;
     readonly name: string;
+    private storage;
+    private afs?;
+    private router;
+    private rootEntries;
     onMount(afs: AFSRoot): void;
     list(path: string, options?: AFSListOptions): Promise<AFSListResult>;
-    read(path: string): Promise<AFSReadResult>;
+    read(path: string, options?: AFSReadOptions): Promise<AFSReadResult>;
+    write(path: string, content: AFSWriteEntryPayload): Promise<AFSWriteResult>;
+    delete(path: string, _options?: AFSDeleteOptions): Promise<AFSDeleteResult>;
+    private normalizePath;
 }

package/lib/dts/storage/index.d.ts

@@ -1,7 +1,6 @@
 import type { AFSEntry, AFSModule } from "@aigne/afs";
 import { initDatabase } from "@aigne/sqlite";
-import { entriesTable } from "./models/entries.js";
-import type { AFSStorage, AFSStorageCreatePayload, AFSStorageListOptions } from "./type.js";
+import type { AFSStorage, AFSStorageCreateOptions, AFSStorageCreatePayload, AFSStorageDeleteOptions, AFSStorageListOptions, AFSStorageReadOptions } from "./type.js";
 export * from "./type.js";
 export interface SharedAFSStorageOptions {
     url?: string;
@@ -17,11 +16,16 @@ export declare class SharedAFSStorage {
 }
 export declare class AFSStorageWithModule implements AFSStorage {
     private db;
-    private table;
-    constructor(db: ReturnType<typeof initDatabase>, table: Promise<ReturnType<typeof entriesTable>>);
+    private module;
+    constructor(db: ReturnType<typeof initDatabase>, module: AFSModule);
+    private _tables?;
+    private get tables();
     list(options?: AFSStorageListOptions): Promise<{
         data: AFSEntry[];
     }>;
-    read(path: string): Promise<AFSEntry | undefined>;
-    create(entry: AFSStorageCreatePayload): Promise<AFSEntry>;
+    read(id: string, options?: AFSStorageReadOptions): Promise<AFSEntry | undefined>;
+    create(entry: AFSStorageCreatePayload, options?: AFSStorageCreateOptions): Promise<AFSEntry>;
+    delete(id: string, options?: AFSStorageDeleteOptions): Promise<{
+        deletedCount: number;
+    }>;
 }

package/lib/dts/storage/migrate.d.ts

@@ -1,3 +1,3 @@
 import type { AFSModule } from "@aigne/afs";
 import { type initDatabase } from "@aigne/sqlite";
-export declare function migrate(db: ReturnType<typeof initDatabase>, module: AFSModule): Promise<void>;
+export declare function migrate(db: Awaited<ReturnType<typeof initDatabase>>, module: AFSModule): Promise<void>;

package/lib/dts/storage/migrations/003-add-compact-table.d.ts

@@ -0,0 +1,2 @@
+import type { AFSStorageMigrations } from "../type.js";
+export declare const addCompactTable: AFSStorageMigrations;

package/lib/dts/storage/migrations/004-add-memory-table.d.ts

@@ -0,0 +1,2 @@
+import type { AFSStorageMigrations } from "../type.js";
+export declare const addMemoryTable: AFSStorageMigrations;

package/lib/dts/storage/migrations/005-add-indexes.d.ts

@@ -0,0 +1,2 @@
+import type { AFSStorageMigrations } from "../type.js";
+export declare const addIndexes: AFSStorageMigrations;