@aigne/afs-sqlite 1.11.0-beta.6 → 1.11.0-beta.8

package/dist/sqlite-afs.mjs

@@ -1,3 +1,4 @@
+import { __require } from "./_virtual/rolldown_runtime.mjs";
 import { registerBuiltInActions } from "./actions/built-in.mjs";
 import { ActionsRegistry } from "./actions/registry.mjs";
 import { sqliteAFSConfigSchema } from "./config.mjs";
@@ -8,7 +9,8 @@ import { SchemaService } from "./schema/service.mjs";
 import { __decorate } from "./_virtual/_@oxc-project_runtime@0.108.0/helpers/decorate.mjs";
 import { initDatabase, sql } from "@aigne/sqlite";
 import { AFSNotFoundError } from "@aigne/afs";
-import { AFSBaseProvider, Actions, Delete, List, Meta, Read, Search, Stat, Write } from "@aigne/afs/provider";
+import { z } from "zod";
+import { AFSBaseProvider, Actions, Delete, Explain, List, Meta, Read, Search, Stat, Write } from "@aigne/afs/provider";
 
 //#region src/sqlite-afs.ts
 /**
@@ -31,6 +33,16 @@ var SQLiteAFS = class SQLiteAFS extends AFSBaseProvider {
 	constructor(options) {
 		super();
 		this.options = options;
+		if (options.localPath && !options.url) options.url = `file:${options.localPath}`;
+		if (options.url.startsWith("file:")) {
+			const { existsSync, mkdirSync, writeFileSync } = __require("node:fs");
+			const { dirname } = __require("node:path");
+			const dbPath = options.url.slice(5);
+			if (!existsSync(dbPath)) {
+				mkdirSync(dirname(dbPath), { recursive: true });
+				writeFileSync(dbPath, "");
+			}
+		}
 		this.name = options.name ?? "sqlite-afs";
 		this.description = options.description ?? `SQLite database: ${options.url}`;
 		this.accessMode = options.accessMode ?? "readwrite";
@@ -44,11 +56,21 @@ var SQLiteAFS = class SQLiteAFS extends AFSBaseProvider {
 	static schema() {
 		return sqliteAFSConfigSchema;
 	}
+	static manifest() {
+		return {
+			name: "sqlite",
+			description: "Mount a SQLite database as a virtual filesystem",
+			uriTemplate: "sqlite://{localPath+}",
+			category: "database",
+			schema: z.object({ localPath: z.string() }),
+			tags: ["sqlite", "database"]
+		};
+	}
 	/**
 	* Loads a module instance from configuration
 	*/
-	static async load({ parsed }) {
-		return new SQLiteAFS(sqliteAFSConfigSchema.parse(parsed));
+	static async load({ config } = {}) {
+		return new SQLiteAFS(sqliteAFSConfigSchema.parse(config));
 	}
 	/**
 	* Initializes the database connection and schema service
@@ -78,33 +100,29 @@ var SQLiteAFS = class SQLiteAFS extends AFSBaseProvider {
 	}
 	/**
 	* List all tables
+	* Note: list() returns only children, never the path itself (per new semantics)
 	*/
 	async listTablesHandler(_ctx) {
 		await this.ensureInitialized();
-		const result = await this.crud.listTables();
-		return { data: [buildRootEntry(await this.schemaService.getAllSchemas(), { basePath: "" }), ...result.data] };
+		return { data: (await this.crud.listTables()).data };
 	}
 	/**
 	* List rows in a table
+	* Note: list() returns only children (rows), never the table itself (per new semantics)
 	*/
 	async listTableHandler(ctx) {
 		await this.ensureInitialized();
-		const schema = await this.schemaService.getSchema(ctx.params.table);
-		if (!schema) throw new AFSNotFoundError(`/${ctx.params.table}`);
-		const result = await this.crud.listTable(ctx.params.table, ctx.options);
-		const rowCount = (await this.db.all(sql.raw(`SELECT COUNT(*) as count FROM "${ctx.params.table}"`)))[0]?.count ?? 0;
-		return { data: [buildTableEntry(ctx.params.table, schema, {
-			basePath: "",
-			rowCount
-		}), ...result.data] };
+		if (!await this.schemaService.getSchema(ctx.params.table)) throw new AFSNotFoundError(`/${ctx.params.table}`);
+		return { data: (await this.crud.listTable(ctx.params.table, ctx.options)).data };
 	}
 	/**
-	* List a row (returns single entry for the row)
+	* List a row - rows are leaf nodes with no children
+	* Note: list() returns only children, never the path itself (per new semantics)
 	*/
 	async listRowHandler(ctx) {
 		await this.ensureInitialized();
-		const result = await this.crud.readRow(ctx.params.table, ctx.params.pk);
-		return { data: result.data ? [result.data] : [] };
+		if (!(await this.crud.readRow(ctx.params.table, ctx.params.pk)).data) throw new AFSNotFoundError(`/${ctx.params.table}/${ctx.params.pk}`);
+		return { data: [] };
 	}
 	/**
 	* List actions for a row
@@ -165,17 +183,80 @@ var SQLiteAFS = class SQLiteAFS extends AFSBaseProvider {
 			path: "/.meta",
 			content: {
 				type: "sqlite",
-				url: this.options.url,
 				tableCount: schemas.size,
 				tables
 			},
-			metadata: {
+			meta: {
 				childrenCount: tables.length,
 				tables: tables.map((t) => t.name)
 			}
 		};
 	}
 	/**
+	* Read capabilities manifest
+	* Returns information about available actions at different levels
+	*/
+	async readCapabilitiesHandler(_ctx) {
+		await this.ensureInitialized();
+		const actionCatalogs = [];
+		const rootActions = this.actions.listWithInfo({ rootLevel: true }, { schemaService: this.schemaService });
+		if (rootActions.length > 0) actionCatalogs.push({
+			kind: "sqlite:root",
+			description: "Database-level operations",
+			catalog: rootActions.map((a) => ({
+				name: a.name,
+				description: a.description,
+				inputSchema: a.inputSchema
+			})),
+			discovery: {
+				pathTemplate: "/.actions",
+				note: "Available at database root"
+			}
+		});
+		const tableActions = this.actions.listWithInfo({ tableLevel: true }, { schemaService: this.schemaService });
+		if (tableActions.length > 0) actionCatalogs.push({
+			kind: "sqlite:table",
+			description: "Table-level operations",
+			catalog: tableActions.map((a) => ({
+				name: a.name,
+				description: a.description,
+				inputSchema: a.inputSchema
+			})),
+			discovery: {
+				pathTemplate: "/:table/.actions",
+				note: "Replace :table with actual table name"
+			}
+		});
+		const rowActions = this.actions.listWithInfo({ rowLevel: true }, { schemaService: this.schemaService });
+		if (rowActions.length > 0) actionCatalogs.push({
+			kind: "sqlite:row",
+			description: "Row-level operations",
+			catalog: rowActions.map((a) => ({
+				name: a.name,
+				description: a.description,
+				inputSchema: a.inputSchema
+			})),
+			discovery: {
+				pathTemplate: "/:table/:pk/.actions",
+				note: "Replace :table with table name, :pk with primary key value"
+			}
+		});
+		return {
+			id: "/.meta/.capabilities",
+			path: "/.meta/.capabilities",
+			content: {
+				schemaVersion: 1,
+				provider: this.name,
+				version: "1.0.0",
+				description: this.description,
+				tools: [],
+				actions: actionCatalogs,
+				operations: this.getOperationsDeclaration()
+			},
+			meta: { kind: "afs:capabilities" }
+		};
+	}
+	/**
 	* Read table (directory) entry
 	*/
 	async readTableHandler(ctx) {
@@ -224,7 +305,7 @@ var SQLiteAFS = class SQLiteAFS extends AFSBaseProvider {
 				})),
 				rowCount
 			},
-			metadata: {
+			meta: {
 				table: ctx.params.table,
 				description: `Table "${ctx.params.table}" with ${columns.length} columns`,
 				childrenCount: rowCount,
@@ -276,7 +357,7 @@ var SQLiteAFS = class SQLiteAFS extends AFSBaseProvider {
 					referencesColumn: fk.to
 				}))
 			},
-			metadata: {
+			meta: {
 				table: ctx.params.table,
 				primaryKeyValue: ctx.params.pk,
 				columns: schema.columns.map((col) => col.name)
@@ -355,12 +436,13 @@ var SQLiteAFS = class SQLiteAFS extends AFSBaseProvider {
 		const schemas = await this.schemaService.getAllSchemas();
 		const actions = this.actions.listWithInfo({ rootLevel: true }, { schemaService: this.schemaService });
 		return { data: {
+			id: "/",
 			path: "/",
-			childrenCount: schemas.size,
 			meta: {
 				kind: "sqlite:database",
 				kinds: ["sqlite:database", "afs:node"],
-				tableCount: schemas.size
+				tableCount: schemas.size,
+				childrenCount: schemas.size
 			},
 			actions: actions.length > 0 ? actions.map((a) => ({
 				name: a.name,
@@ -381,15 +463,23 @@ var SQLiteAFS = class SQLiteAFS extends AFSBaseProvider {
 			tableName: ctx.params.table,
 			schemaService: this.schemaService
 		});
+		const columns = schema.columns.map((col) => ({
+			name: col.name,
+			type: col.type,
+			nullable: !col.notnull,
+			primaryKey: col.pk > 0
+		}));
 		return { data: {
+			id: ctx.params.table,
 			path: `/${ctx.params.table}`,
-			childrenCount: rowCount,
 			meta: {
 				kind: "sqlite:table",
 				kinds: ["sqlite:table", "afs:node"],
 				table: ctx.params.table,
 				columnCount: schema.columns.length,
-				primaryKey: schema.primaryKey[0]
+				columns,
+				primaryKey: schema.primaryKey[0],
+				childrenCount: rowCount
 			},
 			actions: actions.length > 0 ? actions.map((a) => ({
 				name: a.name,
@@ -410,14 +500,23 @@ var SQLiteAFS = class SQLiteAFS extends AFSBaseProvider {
 			tableName: ctx.params.table,
 			schemaService: this.schemaService
 		});
+		const columns = schema.columns.map((col) => ({
+			name: col.name,
+			type: col.type,
+			nullable: !col.notnull,
+			primaryKey: col.pk > 0
+		}));
 		return { data: {
+			id: ctx.params.pk,
 			path: `/${ctx.params.table}/${ctx.params.pk}`,
-			childrenCount: 0,
 			meta: {
 				kind: "sqlite:row",
 				kinds: ["sqlite:row", "afs:node"],
 				table: ctx.params.table,
-				primaryKey: ctx.params.pk
+				primaryKey: ctx.params.pk,
+				columnCount: schema.columns.length,
+				columns,
+				childrenCount: 0
 			},
 			actions: actions.length > 0 ? actions.map((a) => ({
 				name: a.name,
@@ -426,6 +525,139 @@ var SQLiteAFS = class SQLiteAFS extends AFSBaseProvider {
 		} };
 	}
 	/**
+	* Explain root (database level)
+	*/
+	async explainRootHandler(ctx) {
+		await this.ensureInitialized();
+		const format = ctx.options?.format || "markdown";
+		const schemas = await this.schemaService.getAllSchemas();
+		const tables = Array.from(schemas.values());
+		const lines = [];
+		if (format === "markdown") {
+			lines.push(`# ${this.name}`);
+			lines.push("");
+			lines.push(`**Type:** SQLite Database`);
+			lines.push(`**Tables:** ${tables.length}`);
+			lines.push("");
+			if (tables.length > 0) {
+				lines.push("## Tables");
+				lines.push("");
+				lines.push("| Table | Columns | Primary Key |");
+				lines.push("|-------|---------|-------------|");
+				for (const table of tables) {
+					const pk = table.primaryKey.join(", ") || "rowid";
+					lines.push(`| ${table.name} | ${table.columns.length} | ${pk} |`);
+				}
+			}
+		} else {
+			lines.push(`${this.name} (SQLite Database)`);
+			lines.push(`Tables: ${tables.length}`);
+			for (const table of tables) lines.push(`  - ${table.name} (${table.columns.length} columns)`);
+		}
+		return {
+			content: lines.join("\n"),
+			format
+		};
+	}
+	/**
+	* Explain a table
+	*/
+	async explainTableHandler(ctx) {
+		await this.ensureInitialized();
+		const format = ctx.options?.format || "markdown";
+		const schema = await this.schemaService.getSchema(ctx.params.table);
+		if (!schema) throw new AFSNotFoundError(`/${ctx.params.table}`);
+		const rowCount = (await this.db.all(sql.raw(`SELECT COUNT(*) as count FROM "${ctx.params.table}"`)))[0]?.count ?? 0;
+		const lines = [];
+		if (format === "markdown") {
+			lines.push(`# ${ctx.params.table}`);
+			lines.push("");
+			lines.push(`**Type:** SQLite Table`);
+			lines.push(`**Rows:** ${rowCount}`);
+			lines.push(`**Primary Key:** ${schema.primaryKey.join(", ") || "rowid"}`);
+			lines.push("");
+			lines.push("## Columns");
+			lines.push("");
+			lines.push("| Column | Type | Nullable | Primary Key | Default |");
+			lines.push("|--------|------|----------|-------------|---------|");
+			for (const col of schema.columns) {
+				const nullable = col.notnull ? "NO" : "YES";
+				const pk = col.pk > 0 ? "YES" : "";
+				const dflt = col.dfltValue !== null && col.dfltValue !== void 0 ? String(col.dfltValue) : "";
+				lines.push(`| ${col.name} | ${col.type} | ${nullable} | ${pk} | ${dflt} |`);
+			}
+			if (schema.indexes.length > 0) {
+				lines.push("");
+				lines.push("## Indexes");
+				lines.push("");
+				for (const idx of schema.indexes) {
+					const uniqueStr = idx.unique ? " (UNIQUE)" : "";
+					lines.push(`- **${idx.name}**${uniqueStr}`);
+				}
+			}
+			if (schema.foreignKeys.length > 0) {
+				lines.push("");
+				lines.push("## Foreign Keys");
+				lines.push("");
+				for (const fk of schema.foreignKeys) lines.push(`- \`${fk.from}\` → \`${fk.table}\`(\`${fk.to}\`) ON DELETE ${fk.onDelete}`);
+			}
+		} else {
+			lines.push(`${ctx.params.table} (SQLite Table)`);
+			lines.push(`Rows: ${rowCount}`);
+			lines.push(`Primary Key: ${schema.primaryKey.join(", ") || "rowid"}`);
+			lines.push(`Columns: ${schema.columns.map((c) => `${c.name} (${c.type})`).join(", ")}`);
+			if (schema.indexes.length > 0) lines.push(`Indexes: ${schema.indexes.map((i) => i.name).join(", ")}`);
+			if (schema.foreignKeys.length > 0) lines.push(`Foreign Keys: ${schema.foreignKeys.map((fk) => `${fk.from} → ${fk.table}(${fk.to})`).join(", ")}`);
+		}
+		return {
+			content: lines.join("\n"),
+			format
+		};
+	}
+	/**
+	* Explain a row
+	*/
+	async explainRowHandler(ctx) {
+		await this.ensureInitialized();
+		const format = ctx.options?.format || "markdown";
+		const schema = await this.schemaService.getSchema(ctx.params.table);
+		if (!schema) throw new AFSNotFoundError(`/${ctx.params.table}`);
+		const result = await this.crud.readRow(ctx.params.table, ctx.params.pk);
+		if (!result.data) throw new AFSNotFoundError(`/${ctx.params.table}/${ctx.params.pk}`);
+		const rowContent = result.data.content;
+		const pkColumn = schema.primaryKey[0] ?? "rowid";
+		const lines = [];
+		if (format === "markdown") {
+			lines.push(`# ${ctx.params.table}/${ctx.params.pk}`);
+			lines.push("");
+			lines.push(`**Table:** ${ctx.params.table}`);
+			lines.push(`**Primary Key:** ${pkColumn} = ${ctx.params.pk}`);
+			lines.push("");
+			if (rowContent) {
+				lines.push("## Values");
+				lines.push("");
+				lines.push("| Column | Value |");
+				lines.push("|--------|-------|");
+				for (const col of schema.columns) {
+					const val = rowContent[col.name];
+					const displayVal = val === null || val === void 0 ? "*null*" : truncateValue(String(val), 100);
+					lines.push(`| ${col.name} | ${displayVal} |`);
+				}
+			}
+		} else {
+			lines.push(`${ctx.params.table}/${ctx.params.pk} (SQLite Row)`);
+			lines.push(`Table: ${ctx.params.table}, ${pkColumn} = ${ctx.params.pk}`);
+			if (rowContent) for (const col of schema.columns) {
+				const val = rowContent[col.name];
+				lines.push(`  ${col.name}: ${val === null || val === void 0 ? "null" : truncateValue(String(val), 100)}`);
+			}
+		}
+		return {
+			content: lines.join("\n"),
+			format
+		};
+	}
+	/**
 	* Execute action via exec (row-level)
 	*/
 	async handleRowActionExec(ctx, args) {
@@ -562,13 +794,14 @@ var SQLiteAFS = class SQLiteAFS extends AFSBaseProvider {
 	}
 };
 __decorate([List("/")], SQLiteAFS.prototype, "listTablesHandler", null);
-__decorate([List("/:table", { handleDepth: true })], SQLiteAFS.prototype, "listTableHandler", null);
+__decorate([List("/:table")], SQLiteAFS.prototype, "listTableHandler", null);
 __decorate([List("/:table/:pk")], SQLiteAFS.prototype, "listRowHandler", null);
 __decorate([Actions("/:table/:pk")], SQLiteAFS.prototype, "listActionsHandler", null);
 __decorate([Actions("/:table")], SQLiteAFS.prototype, "listTableActionsHandler", null);
 __decorate([Actions("/")], SQLiteAFS.prototype, "listRootActionsHandler", null);
 __decorate([Read("/")], SQLiteAFS.prototype, "readRootHandler", null);
 __decorate([Meta("/")], SQLiteAFS.prototype, "readRootMetaHandler", null);
+__decorate([Read("/.meta/.capabilities")], SQLiteAFS.prototype, "readCapabilitiesHandler", null);
 __decorate([Read("/:table")], SQLiteAFS.prototype, "readTableHandler", null);
 __decorate([Meta("/:table")], SQLiteAFS.prototype, "readTableMetaHandler", null);
 __decorate([Read("/:table/:pk")], SQLiteAFS.prototype, "readRowHandler", null);
@@ -586,9 +819,19 @@ __decorate([Search("/:table")], SQLiteAFS.prototype, "searchTableHandler", null)
 __decorate([Stat("/")], SQLiteAFS.prototype, "statRootHandler", null);
 __decorate([Stat("/:table")], SQLiteAFS.prototype, "statTableHandler", null);
 __decorate([Stat("/:table/:pk")], SQLiteAFS.prototype, "statRowHandler", null);
+__decorate([Explain("/")], SQLiteAFS.prototype, "explainRootHandler", null);
+__decorate([Explain("/:table")], SQLiteAFS.prototype, "explainTableHandler", null);
+__decorate([Explain("/:table/:pk")], SQLiteAFS.prototype, "explainRowHandler", null);
 __decorate([Actions.Exec("/:table/:pk")], SQLiteAFS.prototype, "handleRowActionExec", null);
 __decorate([Actions.Exec("/:table")], SQLiteAFS.prototype, "handleTableActionExec", null);
 __decorate([Actions.Exec("/")], SQLiteAFS.prototype, "handleRootActionExec", null);
+/**
+* Truncate a string value for display purposes.
+*/
+function truncateValue(value, maxLength) {
+	if (value.length <= maxLength) return value;
+	return `${value.slice(0, maxLength)}...`;
+}
 
 //#endregion
 export { SQLiteAFS };