@coffer-org/server 2.0.1 → 2.1.0

package/dist/counts.d.ts

@@ -2,5 +2,14 @@ export interface CountTarget {
     key: string;
     table: string;
 }
+export interface ShelfRef {
+    library: string;
+    shelf: string;
+    standalone?: boolean;
+}
+export declare function countTargetsFor(shelves: ShelfRef[], filter?: {
+    library?: string;
+    shelf?: string;
+}): CountTarget[];
 export declare function buildCountsSql(shelves: CountTarget[]): string[];
 export declare function recordCounts(shelves: CountTarget[]): Promise<Record<string, number>>;

package/dist/counts.js

@@ -1,4 +1,5 @@
 import { getEm } from "./db.js";
+import { shelfTableName } from "./entity-schema.js";
 const CHUNK = 500;
 function quoteIdent(name) {
     return `"${name.replace(/"/g, '""')}"`;
@@ -6,6 +7,13 @@ function quoteIdent(name) {
 function quoteLiteral(value) {
     return `'${value.replace(/'/g, "''")}'`;
 }
+export function countTargetsFor(shelves, filter = {}) {
+    return shelves
+        .filter((s) => s.standalone !== false)
+        .filter((s) => (filter.library ? s.library === filter.library : true))
+        .filter((s) => (filter.shelf ? s.shelf === filter.shelf : true))
+        .map((s) => ({ key: `${s.library}/${s.shelf}`, table: shelfTableName(s.library, s.shelf) }));
+}
 export function buildCountsSql(shelves) {
     const out = [];
     for (let i = 0; i < shelves.length; i += CHUNK) {

package/dist/mcp-local.d.ts

@@ -1,8 +1,15 @@
 import type { CofferClientApi } from '@coffer-org/mcp/client';
 export declare function mapError(e: unknown): never;
+export declare function splitListQuery(raw: Record<string, unknown>): {
+    query: Record<string, unknown>;
+    opts: {
+        limit?: number;
+        offset?: number;
+    };
+};
 export declare class LocalClient implements CofferClientApi {
     getSchema(): Promise<unknown>;
-    listRecords(library: string, shelf: string, query?: Record<string, unknown>): Promise<unknown>;
+    listRecords(library: string, shelf: string, raw?: Record<string, unknown>): Promise<unknown>;
     getRecord(library: string, shelf: string, id: number): Promise<unknown>;
     createRecord(library: string, shelf: string, fields: Record<string, unknown>): Promise<unknown>;
     updateRecord(library: string, shelf: string, id: number, fields: Record<string, unknown>): Promise<unknown>;

package/dist/mcp-local.js

@@ -1,5 +1,5 @@
 import { ValidationError, NotFoundError } from '@coffer-org/mcp/client';
-import { recordList, recordGet, recordCreate, recordUpdate, recordDelete, UnknownShelfError, } from "./records-api.js";
+import { recordList, recordListPage, recordGet, recordCreate, recordUpdate, recordDelete, UnknownShelfError, } from "./records-api.js";
 import { ValidationError as ServerValidationError } from "./mutate.js";
 import { buildClientSchema } from "./schema-api.js";
 export function mapError(e) {
@@ -9,13 +9,22 @@ export function mapError(e) {
         throw new NotFoundError('not_found');
     throw e;
 }
+export function splitListQuery(raw) {
+    const { limit, offset, ...query } = raw;
+    if (typeof limit !== 'number')
+        return { query, opts: {} };
+    return { query, opts: { limit, ...(typeof offset === 'number' ? { offset } : {}) } };
+}
 export class LocalClient {
     async getSchema() {
         return buildClientSchema();
     }
-    async listRecords(library, shelf, query = {}) {
+    async listRecords(library, shelf, raw = {}) {
+        const { query, opts } = splitListQuery(raw);
         try {
-            return await recordList(library, shelf, query);
+            if (opts.limit === undefined)
+                return await recordList(library, shelf, query);
+            return await recordListPage(library, shelf, query, opts);
         }
         catch (e) {
             mapError(e);

package/dist/mcp-tools.js

@@ -6,6 +6,7 @@ import { frontendInstructions } from "./frontend-agent.js";
 import { mintUploadTicket } from "./upload-ticket.js";
 import { pluginHooks, pluginCtx } from "./plugin-hooks.js";
 import { getActiveRegistry } from "./registry-context.js";
+import { countTargetsFor, recordCounts } from "./counts.js";
 import { describeCondition } from '@coffer-org/sdk/condition';
 import { getEm } from "./db.js";
 import { getPluginSettings } from "./plugin-runtime.js";
@@ -72,6 +73,37 @@ export async function collectMcpTools(opts = {}) {
             },
         });
     }
+    out.push({
+        server: 'coffer',
+        bareName: 'count_records',
+        httpName: 'count_records',
+        description: 'How many records each shelf holds — counted in the database, no rows returned. ' +
+            'Without arguments: every shelf of every library. library — narrow to one library; shelf — to one shelf ' +
+            '(needs library). Use this for "how many …" and for a size overview; never list records just to count them.',
+        inputSchema: { library: z.string().optional(), shelf: z.string().optional() },
+        scope: 'crud',
+        role: 'member',
+        handler: async (args) => {
+            try {
+                const registry = getActiveRegistry();
+                const targets = countTargetsFor(registry.shelves, {
+                    ...(typeof args.library === 'string' ? { library: args.library } : {}),
+                    ...(typeof args.shelf === 'string' ? { shelf: args.shelf } : {}),
+                });
+                const counts = await recordCounts(targets);
+                const shelves = Object.entries(counts)
+                    .map(([key, count]) => {
+                    const [library = '', shelf = ''] = key.split('/');
+                    return { library, shelf, count };
+                })
+                    .sort((a, b) => b.count - a.count);
+                return ok({ shelves, total: shelves.reduce((n, s) => n + s.count, 0) });
+            }
+            catch (e) {
+                return fail(`Error: ${e.message}`);
+            }
+        },
+    });
     for (const [id, h] of Object.entries(pluginHooks)) {
         for (const t of h.agent?.tools ?? []) {
             out.push({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coffer-org/server",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "type": "module",
   "engines": {
     "node": ">=24"