faces-cli 1.7.14 → 1.7.16

package/dist/commands/compile/doc/list.d.ts

@@ -2,6 +2,7 @@ import { BaseCommand } from '../../../base.js';
 export default class CompileDocList extends BaseCommand {
     static description: string;
     static flags: {
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'base-url': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         token: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'api-key': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;

package/dist/commands/compile/doc/list.js

@@ -1,10 +1,12 @@
-import { Args } from '@oclif/core';
+import { Args, Flags } from '@oclif/core';
 import { BaseCommand } from '../../../base.js';
 import { FacesAPIError } from '../../../client.js';
 export default class CompileDocList extends BaseCommand {
-    static description = 'List documents for a face';
+    static description = "List documents for a face. Each document's full text is omitted unless --verbose, so a face with a " +
+        'real corpus stays readable. For a table of every source, documents and threads together, use face:sources.';
     static flags = {
         ...BaseCommand.baseFlags,
+        verbose: Flags.boolean({ description: "Include each document's full text", default: false }),
     };
     static args = {
         face_id: Args.string({ description: 'Face alias', required: true }),
@@ -21,8 +23,21 @@ export default class CompileDocList extends BaseCommand {
                 this.error(`Error (${err.statusCode}): ${err.message}`);
             throw err;
         }
-        if (!this.jsonEnabled())
-            this.printHuman(data);
+        // --json is untouched: machine callers may already read `content`, and
+        // dropping a field from structured output would break them silently.
+        if (!this.jsonEnabled()) {
+            const items = Array.isArray(data) ? data : [];
+            const omitted = flags.verbose ? 0 : items.filter((d) => typeof d.content === 'string' && d.content !== '').length;
+            this.printHuman(flags.verbose
+                ? data
+                : items.map((d) => Object.fromEntries(Object.entries(d).filter(([k]) => k !== 'content'))));
+            // Say that something was left out. A list that quietly drops a field
+            // reads as complete, which is how this became a problem in the first place.
+            if (omitted > 0) {
+                this.log('');
+                this.log(`Text omitted for ${omitted} document(s). Pass --verbose to include it.`);
+            }
+        }
         return data;
     }
 }

package/dist/commands/face/sources.d.ts

@@ -0,0 +1,20 @@
+import { BaseCommand } from '../../base.js';
+export default class FaceSources extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        type: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'base-url': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        token: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'api-key': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static args: {
+        alias: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<unknown>;
+    private fetch;
+    private statusOf;
+    private toRow;
+    private toJson;
+    private render;
+}

package/dist/commands/face/sources.js

@@ -0,0 +1,150 @@
+import { Args, Flags } from '@oclif/core';
+import { BaseCommand } from '../../base.js';
+import { FacesAPIError } from '../../client.js';
+/** Exit code for "no such face", so a caller can tell it from an empty face. */
+const EXIT_NO_SUCH_FACE = 4;
+export default class FaceSources extends BaseCommand {
+    static description = 'List every source compiled into a face: documents and threads together, one row each. ' +
+        `Exits ${EXIT_NO_SUCH_FACE} if the face does not exist, which is a different answer from a face that ` +
+        'has no sources. Content is never printed; read a single source with compile:doc:get or compile:thread:get.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> alice',
+        '<%= config.bin %> <%= command.id %> alice --type thread',
+        '<%= config.bin %> <%= command.id %> alice --json',
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        type: Flags.string({ description: 'Show only one kind of source', options: ['doc', 'thread'] }),
+    };
+    static args = {
+        alias: Args.string({ description: 'Face alias', required: true }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(FaceSources);
+        const client = this.makeClient(flags);
+        const json = this.jsonEnabled();
+        const alias = encodeURIComponent(args.alias);
+        const wantDocs = flags.type !== 'thread';
+        const wantThreads = flags.type !== 'doc';
+        // A face that does not exist and a face with nothing in it are opposite
+        // answers. The API distinguishes them with a 404, so this must too — by
+        // message and by exit code, since a script only sees the latter.
+        const docs = wantDocs ? await this.fetch(client, `/v1/compile/documents?alias=${alias}`, args.alias) : [];
+        // include_uploads defaults to excluding upload-created threads. This command
+        // claims to list every source, so it asks for them explicitly.
+        const threads = wantThreads
+            ? await this.fetch(client, `/v1/compile/threads?alias=${alias}&include_uploads=true`, args.alias)
+            : [];
+        const rows = [...docs.map((d) => this.toRow(d, 'doc')), ...threads.map((t) => this.toRow(t, 'thread'))];
+        rows.sort((a, b) => (b.updated || '').localeCompare(a.updated || '') || a.label.localeCompare(b.label));
+        if (json) {
+            return {
+                alias: args.alias,
+                documents: docs.map((d) => this.toJson(d, 'doc')),
+                threads: threads.map((t) => this.toJson(t, 'thread')),
+                totals: {
+                    sources: rows.length,
+                    tokens: rows.reduce((n, r) => n + r.tokens, 0),
+                    not_synced: rows.filter((r) => !r.synced).length,
+                },
+            };
+        }
+        this.render(args.alias, rows, flags.type);
+        return { alias: args.alias, sources: rows.length };
+    }
+    async fetch(client, path, alias) {
+        try {
+            const data = await client.get(path);
+            return (Array.isArray(data) ? data : (data.data ?? []));
+        }
+        catch (err) {
+            if (err instanceof FacesAPIError) {
+                if (err.statusCode === 404) {
+                    this.error(`No face named '${alias}'. It does not exist, or is not owned by this account.`, {
+                        exit: EXIT_NO_SUCH_FACE,
+                    });
+                }
+                this.error(`Error (${err.statusCode}): ${err.message}`);
+            }
+            throw err;
+        }
+    }
+    statusOf(s) {
+        if (s.synced)
+            return 'synced';
+        const st = s.prepare_status;
+        const done = s.chunks_completed;
+        const total = s.chunks_total;
+        const progress = done !== null && done !== undefined && total ? ` ${done}/${total}` : '';
+        if (st)
+            return `${st}${progress}`;
+        return 'not compiled';
+    }
+    toRow(s, type) {
+        return {
+            type,
+            id: String(s.document_id ?? s.thread_id ?? ''),
+            label: s.label?.trim() || '(untitled)',
+            tokens: s.token_count ?? 0,
+            status: this.statusOf(s),
+            medium: s.medium?.trim() || '-',
+            updated: (s.updated_at ?? s.created_at ?? '').slice(0, 10) || '-',
+            synced: Boolean(s.synced),
+        };
+    }
+    toJson(s, type) {
+        const out = {
+            type,
+            // A stable id, because anything that later deletes or recompiles a source
+            // needs one — the label is for people and is not unique.
+            id: String(s.document_id ?? s.thread_id ?? ''),
+            label: s.label ?? null,
+            token_count: s.token_count ?? 0,
+            status: this.statusOf(s),
+            synced: Boolean(s.synced),
+            prepare_status: s.prepare_status ?? null,
+            medium: s.medium ?? null,
+            created_at: s.created_at ?? null,
+            updated_at: s.updated_at ?? null,
+            read_only: Boolean(s.read_only),
+        };
+        if (type === 'doc')
+            out.document_id = s.document_id;
+        if (type === 'thread') {
+            out.thread_id = s.thread_id;
+            out.message_count = s.message_count ?? null;
+        }
+        return out;
+    }
+    render(alias, rows, type) {
+        if (rows.length === 0) {
+            const what = type ? `${type} sources` : 'sources';
+            this.log(`'${alias}' exists and has no ${what}.`);
+            return;
+        }
+        const n = (v) => v.toLocaleString('en-US');
+        const cols = [
+            ['TYPE', (r) => r.type],
+            ['LABEL', (r) => r.label],
+            ['TOKENS', (r) => n(r.tokens)],
+            ['STATUS', (r) => r.status],
+            ['MEDIUM', (r) => r.medium],
+            ['UPDATED', (r) => r.updated],
+        ];
+        const widths = cols.map(([h, get]) => Math.max(h.length, ...rows.map((r) => get(r).length)));
+        const line = (cells) => cells.map((c, i) => (cols[i][0] === 'TOKENS' ? c.padStart(widths[i]) : c.padEnd(widths[i]))).join('  ').trimEnd();
+        this.log(line(cols.map(([h]) => h)));
+        for (const r of rows)
+            this.log(line(cols.map(([, get]) => get(r))));
+        // Say what the total counts. Every listed row is included, so the column
+        // adds up to the figure shown; anything not yet compiled is called out
+        // separately rather than quietly left out of the sum.
+        const tokens = rows.reduce((a, r) => a + r.tokens, 0);
+        const pending = rows.filter((r) => !r.synced).length;
+        this.log('');
+        this.log(`${n(tokens)} tokens across all ${rows.length} source(s) listed.`);
+        if (pending > 0) {
+            this.log(`${pending} not yet synced. Their tokens are included in that total.`);
+        }
+    }
+}