@aigne/afs 1.0.0

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

@@ -0,0 +1,199 @@
+import type { AFSModule } from "../../type.js";
+export declare const entriesTableName: (module: AFSModule) => string;
+export declare const entriesTable: (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;
+        }>;
+        summary: import("@aigne/sqlite").SQLiteColumn<{
+            name: "summary";
+            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: 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";
+        }>;
+        linkTo: import("@aigne/sqlite").SQLiteColumn<{
+            name: "linkTo";
+            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;
+        }>;
+        content: import("@aigne/sqlite").SQLiteColumn<{
+            name: string;
+            tableName: string;
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: any;
+            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/entries.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.entriesTable = exports.entriesTableName = void 0;
+const sqlite_1 = require("@aigne/sqlite");
+const uuid_1 = require("@aigne/uuid");
+const entriesTableName = (module) => `Entries_${module.moduleId}`;
+exports.entriesTableName = entriesTableName;
+const entriesTable = (module) => (0, sqlite_1.sqliteTable)((0, exports.entriesTableName)(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"),
+    summary: (0, sqlite_1.text)("summary"),
+    metadata: (0, sqlite_1.json)("metadata"),
+    linkTo: (0, sqlite_1.text)("linkTo"),
+    content: (0, sqlite_1.json)("content"),
+});
+exports.entriesTable = entriesTable;

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

@@ -0,0 +1,23 @@
+import type { SQL } from "@aigne/sqlite";
+import type { AFSEntry, AFSModule } from "../type.js";
+export interface AFSStorageCreatePayload extends Omit<AFSEntry, "id"> {
+}
+export interface AFSStorageListOptions {
+    filter?: {
+        userId?: string;
+        sessionId?: string;
+    };
+    limit?: number;
+    orderBy?: [string, "asc" | "desc"][];
+}
+export interface AFSStorage {
+    create(entry: AFSStorageCreatePayload): Promise<AFSEntry>;
+    list(options?: AFSStorageListOptions): Promise<{
+        list: AFSEntry[];
+    }>;
+    read(path: string): Promise<AFSEntry | undefined>;
+}
+export type AFSStorageMigrations = {
+    hash: string;
+    sql: (module: AFSModule) => SQL[];
+};

package/lib/cjs/storage/type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/type.d.ts

@@ -0,0 +1,54 @@
+import type { Emitter } from "strict-event-emitter";
+import type { AFSStorage } from "./storage/type.js";
+export interface AFSListOptions {
+    filter?: {
+        userId?: string;
+        sessionId?: string;
+    };
+    recursive?: boolean;
+    maxDepth?: number;
+    limit?: number;
+    orderBy?: [string, "asc" | "desc"][];
+}
+export interface AFSSearchOptions {
+    limit?: number;
+}
+export interface AFSWriteEntryPayload extends Omit<AFSEntry, "id" | "path"> {
+}
+export interface AFSModule {
+    readonly moduleId: string;
+    readonly path: string;
+    onMount?(root: AFSRoot): void;
+    list?(path: string, options?: AFSListOptions): Promise<{
+        list: AFSEntry[];
+    }>;
+    read?(path: string): Promise<AFSEntry | undefined>;
+    write?(path: string, content: AFSWriteEntryPayload): Promise<AFSEntry>;
+    search?(path: string, query: string, options?: AFSSearchOptions): Promise<{
+        list: AFSEntry[];
+    }>;
+}
+export type AFSRootEvents = {
+    agentSucceed: [{
+        input: object;
+        output: object;
+    }];
+    historyCreated: [{
+        entry: AFSEntry;
+    }];
+};
+export interface AFSRoot extends Emitter<AFSRootEvents>, AFSModule {
+    storage(module: AFSModule): AFSStorage;
+}
+export interface AFSEntry<T = any> {
+    id: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    path: string;
+    userId?: string | null;
+    sessionId?: string | null;
+    summary?: string | null;
+    metadata?: Record<string, any> | null;
+    linkTo?: string | null;
+    content?: T;
+}

package/lib/cjs/type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/dts/afs.d.ts

@@ -0,0 +1,26 @@
+import { Emitter } from "strict-event-emitter";
+import { SharedAFSStorage, type SharedAFSStorageOptions } from "./storage/index.js";
+import type { AFSStorage } from "./storage/type.js";
+import type { AFSEntry, AFSListOptions, AFSModule, AFSRoot, AFSRootEvents, AFSSearchOptions, AFSWriteEntryPayload } from "./type.js";
+export interface AFSOptions {
+    storage?: SharedAFSStorage | SharedAFSStorageOptions;
+}
+export declare class AFS extends Emitter<AFSRootEvents> implements AFSRoot {
+    moduleId: string;
+    path: string;
+    constructor(options?: AFSOptions);
+    private _storage;
+    storage(module: AFSModule): AFSStorage;
+    private modules;
+    use(module: AFSModule): this;
+    list(path: string, options?: AFSListOptions): Promise<{
+        list: AFSEntry[];
+    }>;
+    private findModules;
+    private isSubpath;
+    read(path: string): Promise<AFSEntry | undefined>;
+    write(path: string, content: AFSWriteEntryPayload): Promise<AFSEntry>;
+    search(path: string, query: string, options?: AFSSearchOptions): Promise<{
+        list: AFSEntry[];
+    }>;
+}

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

@@ -0,0 +1,14 @@
+import type { AFSEntry, AFSListOptions, AFSModule, AFSRoot, AFSWriteEntryPayload } from "../type.js";
+export declare class AFSHistory implements AFSModule {
+    static Path: string;
+    path: string;
+    moduleId: string;
+    private _afs?;
+    get afs(): AFSRoot;
+    onMount(afs: AFSRoot): void;
+    list(path: string, options?: AFSListOptions): Promise<{
+        list: AFSEntry[];
+    }>;
+    read(path: string): Promise<AFSEntry | undefined>;
+    write(path: string, content: AFSWriteEntryPayload): Promise<AFSEntry>;
+}

package/lib/dts/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./afs.js";
+export * from "./history/index.js";
+export * from "./storage/index.js";
+export * from "./type.js";

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

@@ -0,0 +1,24 @@
+import { initDatabase } from "@aigne/sqlite";
+import type { AFSEntry, AFSModule } from "../type.js";
+import { entriesTable } from "./models/entries.js";
+import type { AFSStorage, AFSStorageCreatePayload, AFSStorageListOptions } from "./type.js";
+export interface SharedAFSStorageOptions {
+    url?: string;
+}
+export declare class SharedAFSStorage {
+    options?: SharedAFSStorageOptions | undefined;
+    constructor(options?: SharedAFSStorageOptions | undefined);
+    private _db;
+    get db(): Promise<import("drizzle-orm/libsql").LibSQLDatabase<Record<string, never>>>;
+    withModule(module: AFSModule): AFSStorage;
+}
+export declare class AFSStorageWithModule implements AFSStorage {
+    private db;
+    private table;
+    constructor(db: ReturnType<typeof initDatabase>, table: Promise<ReturnType<typeof entriesTable>>);
+    list(options?: AFSStorageListOptions): Promise<{
+        list: AFSEntry[];
+    }>;
+    read(path: string): Promise<AFSEntry | undefined>;
+    create(entry: AFSStorageCreatePayload): Promise<AFSEntry>;
+}

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

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

package/lib/dts/storage/migrations/001-init.d.ts

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

package/lib/dts/storage/models/entries.d.ts

@@ -0,0 +1,199 @@
+import type { AFSModule } from "../../type.js";
+export declare const entriesTableName: (module: AFSModule) => string;
+export declare const entriesTable: (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;
+        }>;
+        summary: import("@aigne/sqlite").SQLiteColumn<{
+            name: "summary";
+            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: 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";
+        }>;
+        linkTo: import("@aigne/sqlite").SQLiteColumn<{
+            name: "linkTo";
+            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;
+        }>;
+        content: import("@aigne/sqlite").SQLiteColumn<{
+            name: string;
+            tableName: string;
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: any;
+            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/dts/storage/type.d.ts

@@ -0,0 +1,23 @@
+import type { SQL } from "@aigne/sqlite";
+import type { AFSEntry, AFSModule } from "../type.js";
+export interface AFSStorageCreatePayload extends Omit<AFSEntry, "id"> {
+}
+export interface AFSStorageListOptions {
+    filter?: {
+        userId?: string;
+        sessionId?: string;
+    };
+    limit?: number;
+    orderBy?: [string, "asc" | "desc"][];
+}
+export interface AFSStorage {
+    create(entry: AFSStorageCreatePayload): Promise<AFSEntry>;
+    list(options?: AFSStorageListOptions): Promise<{
+        list: AFSEntry[];
+    }>;
+    read(path: string): Promise<AFSEntry | undefined>;
+}
+export type AFSStorageMigrations = {
+    hash: string;
+    sql: (module: AFSModule) => SQL[];
+};

package/lib/dts/type.d.ts

@@ -0,0 +1,54 @@
+import type { Emitter } from "strict-event-emitter";
+import type { AFSStorage } from "./storage/type.js";
+export interface AFSListOptions {
+    filter?: {
+        userId?: string;
+        sessionId?: string;
+    };
+    recursive?: boolean;
+    maxDepth?: number;
+    limit?: number;
+    orderBy?: [string, "asc" | "desc"][];
+}
+export interface AFSSearchOptions {
+    limit?: number;
+}
+export interface AFSWriteEntryPayload extends Omit<AFSEntry, "id" | "path"> {
+}
+export interface AFSModule {
+    readonly moduleId: string;
+    readonly path: string;
+    onMount?(root: AFSRoot): void;
+    list?(path: string, options?: AFSListOptions): Promise<{
+        list: AFSEntry[];
+    }>;
+    read?(path: string): Promise<AFSEntry | undefined>;
+    write?(path: string, content: AFSWriteEntryPayload): Promise<AFSEntry>;
+    search?(path: string, query: string, options?: AFSSearchOptions): Promise<{
+        list: AFSEntry[];
+    }>;
+}
+export type AFSRootEvents = {
+    agentSucceed: [{
+        input: object;
+        output: object;
+    }];
+    historyCreated: [{
+        entry: AFSEntry;
+    }];
+};
+export interface AFSRoot extends Emitter<AFSRootEvents>, AFSModule {
+    storage(module: AFSModule): AFSStorage;
+}
+export interface AFSEntry<T = any> {
+    id: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    path: string;
+    userId?: string | null;
+    sessionId?: string | null;
+    summary?: string | null;
+    metadata?: Record<string, any> | null;
+    linkTo?: string | null;
+    content?: T;
+}