@aigne/afs 1.0.0

package/lib/esm/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/esm/afs.js

@@ -0,0 +1,122 @@
+import { Emitter } from "strict-event-emitter";
+import { joinURL } from "ufo";
+import { AFSHistory } from "./history/index.js";
+import { SharedAFSStorage } from "./storage/index.js";
+const DEFAULT_MAX_DEPTH = 5;
+export class AFS extends Emitter {
+    moduleId = "AFSRoot";
+    path = "/";
+    constructor(options) {
+        super();
+        this._storage =
+            options?.storage instanceof SharedAFSStorage
+                ? options.storage
+                : new SharedAFSStorage(options?.storage);
+        this.use(new AFSHistory());
+    }
+    _storage;
+    storage(module) {
+        return this._storage.withModule(module);
+    }
+    modules = new Map();
+    use(module) {
+        this.modules.set(module.path, module);
+        module.onMount?.(this);
+        return this;
+    }
+    async list(path, options) {
+        const maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
+        if (!(maxDepth >= 0))
+            throw new Error(`Invalid maxDepth: ${maxDepth}`);
+        const results = [];
+        const modules = this.findModules(path);
+        for (const { module, subpath, mountPath } of modules) {
+            if (!module.list)
+                continue;
+            try {
+                const newMaxDepth = maxDepth - mountPath.split("/").filter(Boolean).length;
+                if (newMaxDepth < 0)
+                    continue;
+                const { list } = await module.list(subpath, { ...options, maxDepth: newMaxDepth });
+                results.push(...list.map((entry) => ({
+                    ...entry,
+                    path: joinURL(mountPath, entry.path),
+                })));
+            }
+            catch (error) {
+                console.error(`Error listing from module at ${mountPath}`, error);
+            }
+        }
+        return { list: results };
+    }
+    findModules(fullPath) {
+        const modules = [];
+        for (const [mountPath, module] of this.modules) {
+            const match = this.isSubpath(fullPath, mountPath);
+            if (!match)
+                continue;
+            modules.push({ ...match, module, mountPath });
+        }
+        return modules.sort((a, b) => b.matchedDepth - a.matchedDepth);
+    }
+    isSubpath(fullPath, mountPath) {
+        const fullPathSegments = fullPath.split("/").filter(Boolean);
+        const mountPathSegments = mountPath.split("/").filter(Boolean);
+        const fp = fullPathSegments.join("/");
+        const mp = mountPathSegments.join("/");
+        if (fp.startsWith(mp)) {
+            return {
+                matchedDepth: mountPathSegments.length,
+                subpath: joinURL("/", ...fullPathSegments.slice(mountPathSegments.length)),
+            };
+        }
+        else if (mp.startsWith(fp)) {
+            return {
+                matchedDepth: fullPathSegments.length,
+                subpath: joinURL("/", ...mountPathSegments.slice(fullPathSegments.length)),
+            };
+        }
+    }
+    async read(path) {
+        const modules = this.findModules(path);
+        for (const { module, mountPath, subpath } of modules) {
+            const entry = await module.read?.(subpath);
+            if (entry) {
+                return {
+                    ...entry,
+                    path: joinURL(mountPath, entry.path),
+                };
+            }
+        }
+    }
+    async write(path, content) {
+        const module = this.findModules(path)[0];
+        if (!module?.module.write)
+            throw new Error(`No module found for path: ${path}`);
+        const entry = await module.module.write(module.subpath, content);
+        return {
+            ...entry,
+            path: joinURL(module.mountPath, entry.path),
+        };
+    }
+    async search(path, query, options) {
+        const results = [];
+        for (const { module, mountPath, subpath } of this.findModules(path)) {
+            if (mountPath.startsWith(path)) {
+                if (!module.search)
+                    continue;
+                try {
+                    const { list } = await module.search(subpath, query, options);
+                    results.push(...list.map((entry) => ({
+                        ...entry,
+                        path: joinURL(mountPath, entry.path),
+                    })));
+                }
+                catch (error) {
+                    console.error(`Error searching in module at ${mountPath}`, error);
+                }
+            }
+        }
+        return { list: results };
+    }
+}

package/lib/esm/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/esm/history/index.js

@@ -0,0 +1,41 @@
+import { v7 } from "@aigne/uuid";
+import { joinURL } from "ufo";
+export class AFSHistory {
+    static Path = "/history";
+    path = AFSHistory.Path;
+    moduleId = "AFSHistory";
+    _afs;
+    get afs() {
+        if (!this._afs)
+            throw new Error("AFSHistory module is not mounted");
+        return this._afs;
+    }
+    onMount(afs) {
+        this._afs = afs;
+        afs.on("agentSucceed", ({ input, output }) => {
+            this.afs
+                .storage(this)
+                .create({
+                path: joinURL("/", v7()),
+                content: { input, output },
+            })
+                .then((entry) => {
+                afs.emit("historyCreated", { entry });
+            })
+                .catch((error) => {
+                console.error("Failed to store history entry", error);
+            });
+        });
+    }
+    async list(path, options) {
+        if (path !== "/")
+            return { list: [] };
+        return this.afs.storage(this).list(options);
+    }
+    async read(path) {
+        return this.afs.storage(this).read(path);
+    }
+    async write(path, content) {
+        return this.afs.storage(this).create({ ...content, path });
+    }
+}

package/lib/esm/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/esm/index.js

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

package/lib/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/lib/esm/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/esm/storage/index.js

@@ -0,0 +1,67 @@
+import { and, asc, desc, eq, initDatabase, sql } from "@aigne/sqlite";
+import { migrate } from "./migrate.js";
+import { entriesTable } from "./models/entries.js";
+const DEFAULT_AFS_STORAGE_LIST_LIMIT = 10;
+export class SharedAFSStorage {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    _db;
+    get db() {
+        this._db ??= initDatabase({ url: this.options?.url });
+        return this._db;
+    }
+    withModule(module) {
+        return new AFSStorageWithModule(this.db, migrate(this.db, module).then(() => entriesTable(module)));
+    }
+}
+export class AFSStorageWithModule {
+    db;
+    table;
+    constructor(db, table) {
+        this.db = db;
+        this.table = table;
+    }
+    async list(options = {}) {
+        const { filter, limit = DEFAULT_AFS_STORAGE_LIST_LIMIT } = options;
+        const db = await this.db;
+        const table = await this.table;
+        const list = await db
+            .select()
+            .from(table)
+            .where(and(filter?.userId ? eq(table.userId, filter.userId) : undefined, filter?.sessionId ? eq(table.sessionId, filter.sessionId) : undefined))
+            .orderBy(...(options.orderBy ?? []).map((item) => (item[1] === "asc" ? asc : desc)(sql.identifier(item[0]))))
+            .limit(limit)
+            .execute();
+        return { list };
+    }
+    async read(path) {
+        const db = await this.db;
+        const table = await this.table;
+        return db
+            .select()
+            .from(table)
+            .where(eq(table.path, path))
+            .limit(1)
+            .execute()
+            .then((memory) => memory.at(0));
+    }
+    async create(entry) {
+        const db = await this.db;
+        const table = await this.table;
+        let result = await db
+            .update(table)
+            .set(entry)
+            .where(eq(table.path, entry.path))
+            .returning()
+            .execute();
+        if (!result.length) {
+            result = await db.insert(table).values(entry).returning().execute();
+        }
+        const [res] = result;
+        if (!res)
+            throw new Error("Failed to create AFS entry, no result");
+        return res;
+    }
+}

package/lib/esm/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/esm/storage/migrate.js

@@ -0,0 +1,28 @@
+import { sql } from "@aigne/sqlite";
+import { v7 } from "@aigne/uuid";
+import { init } from "./migrations/001-init.js";
+export async function migrate(db, module) {
+    const migrations = [init];
+    const migrationsTable = "__drizzle_migrations";
+    const migrationTableCreate = sql `
+    CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (
+      "id" SERIAL PRIMARY KEY,
+      "moduleId" TEXT NOT NULL,
+      "hash" TEXT NOT NULL
+    )
+  `;
+    await (await db).run(migrationTableCreate).execute();
+    const dbMigrations = await (await db)
+        .values(sql `SELECT "id", "moduleId", "hash" FROM ${sql.identifier(migrationsTable)} WHERE "moduleId" = ${sql.param(module.moduleId)} ORDER BY id DESC LIMIT 1`)
+        .execute();
+    const lastDbMigration = dbMigrations[0];
+    const queriesToRun = [];
+    for (const migration of migrations) {
+        if (!lastDbMigration || lastDbMigration[1] < migration.hash) {
+            queriesToRun.push(...migration.sql(module), sql `INSERT INTO ${sql.identifier(migrationsTable)} ("id", "moduleId", "hash") VALUES(${sql.param(v7())}, ${sql.param(module.moduleId)}, ${sql.param(migration.hash)})`);
+        }
+    }
+    for (const query of queriesToRun) {
+        await (await db).run(query).execute();
+    }
+}

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

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

package/lib/esm/storage/migrations/001-init.js

@@ -0,0 +1,22 @@
+import { sql } from "@aigne/sqlite";
+import { entriesTableName } from "../models/entries.js";
+export const init = {
+    hash: "001-init",
+    sql: (module) => [
+        sql `\
+CREATE TABLE ${sql.identifier(entriesTableName(module))} (
+  "id" TEXT NOT NULL PRIMARY KEY,
+  "createdAt" DATETIME NOT NULL,
+  "updatedAt" DATETIME NOT NULL,
+  "path" TEXT NOT NULL,
+  "userId" TEXT,
+  "sessionId" TEXT,
+  "summary" TEXT,
+  "metadata" JSON,
+  "linkTo" TEXT,
+  "content" JSON,
+  UNIQUE (path)
+)
+`,
+    ],
+};

package/lib/esm/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/esm/storage/models/entries.js

@@ -0,0 +1,23 @@
+import { datetime, json, sqliteTable, text } from "@aigne/sqlite";
+import { v7 } from "@aigne/uuid";
+export const entriesTableName = (module) => `Entries_${module.moduleId}`;
+export const entriesTable = (module) => sqliteTable(entriesTableName(module), {
+    id: text("id")
+        .notNull()
+        .primaryKey()
+        .$defaultFn(() => v7()),
+    createdAt: datetime("createdAt")
+        .notNull()
+        .$defaultFn(() => new Date()),
+    updatedAt: datetime("updatedAt")
+        .notNull()
+        .$defaultFn(() => new Date())
+        .$onUpdateFn(() => new Date()),
+    path: text("path").notNull(),
+    userId: text("userId"),
+    sessionId: text("sessionId"),
+    summary: text("summary"),
+    metadata: json("metadata"),
+    linkTo: text("linkTo"),
+    content: json("content"),
+});

package/lib/esm/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/esm/storage/type.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/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/esm/type.js

@@ -0,0 +1 @@
+export {};