faces-cli 1.3.2 → 1.4.1

package/dist/catalog.d.ts

@@ -0,0 +1,36 @@
+export declare const CATALOG_DIR: string;
+export declare const CATALOG_INDEX: string;
+export interface FaceFrontmatter {
+    name: string;
+    description?: string;
+    facename: string;
+    attributes?: Record<string, string>;
+    component_counts?: {
+        alpha: number;
+        beta: number;
+        delta: number;
+        epsilon: number;
+    };
+    profile_token_count?: number;
+}
+export interface FaceDataInput {
+    name: string;
+    id: string;
+    uid?: string;
+    basic_facts?: Record<string, string | {
+        value: string;
+    }> | null;
+    component_counts?: {
+        alpha: number;
+        beta: number;
+        delta: number;
+        epsilon: number;
+    } | null;
+    profile_token_count?: number | null;
+}
+export declare class CatalogService {
+    isEnabled(): boolean;
+    writeFace(faceData: FaceDataInput, description?: string): void;
+    deleteFace(username: string): void;
+    rebuildIndex(): void;
+}

package/dist/catalog.js

@@ -0,0 +1,167 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { loadConfig } from './config.js';
+export const CATALOG_DIR = path.join(os.homedir(), '.faces', 'catalog');
+export const CATALOG_INDEX = path.join(os.homedir(), '.faces', 'catalog.json');
+function quoteYaml(value) {
+    if (/[:#\[\]{}&*!|>'"%@`]/.test(value) || value !== value.trim() || value === '') {
+        return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+    }
+    return value;
+}
+function serializeFrontmatter(fm) {
+    const lines = ['---'];
+    lines.push(`name: ${quoteYaml(fm.name)}`);
+    if (fm.description)
+        lines.push(`description: ${quoteYaml(fm.description)}`);
+    lines.push(`facename: ${quoteYaml(fm.facename)}`);
+    if (fm.attributes && Object.keys(fm.attributes).length > 0) {
+        lines.push('attributes:');
+        for (const [k, v] of Object.entries(fm.attributes)) {
+            lines.push(`  ${k}: ${quoteYaml(String(v))}`);
+        }
+    }
+    if (fm.component_counts) {
+        const cc = fm.component_counts;
+        lines.push(`component_counts: ${cc.alpha + cc.beta + cc.delta + cc.epsilon}`);
+    }
+    if (fm.profile_token_count) {
+        lines.push(`profile_token_count: ${fm.profile_token_count}`);
+    }
+    lines.push('---');
+    return lines.join('\n');
+}
+function parseFrontmatter(content) {
+    const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+    if (!match)
+        return { frontmatter: null, body: content };
+    const yamlBlock = match[1];
+    const body = match[2];
+    const fm = {};
+    let inAttributes = false;
+    const attributes = {};
+    for (const line of yamlBlock.split('\n')) {
+        if (line.startsWith('  ') && inAttributes) {
+            const colonIdx = line.indexOf(':');
+            if (colonIdx > 0) {
+                const k = line.slice(0, colonIdx).trim();
+                const v = line.slice(colonIdx + 1).trim().replace(/^"(.*)"$/, '$1');
+                attributes[k] = v;
+            }
+            continue;
+        }
+        inAttributes = false;
+        const colonIdx = line.indexOf(':');
+        if (colonIdx < 0)
+            continue;
+        const key = line.slice(0, colonIdx).trim();
+        const val = line.slice(colonIdx + 1).trim().replace(/^"(.*)"$/, '$1');
+        if (key === 'name')
+            fm.name = val;
+        else if (key === 'description')
+            fm.description = val;
+        else if (key === 'facename')
+            fm.facename = val;
+        else if (key === 'attributes')
+            inAttributes = true;
+    }
+    if (Object.keys(attributes).length > 0)
+        fm.attributes = attributes;
+    if (!fm.name || !fm.facename)
+        return { frontmatter: null, body: content };
+    return { frontmatter: fm, body };
+}
+const DEFAULT_BODY = '\n## Notes\n\n';
+export class CatalogService {
+    isEnabled() {
+        const cfg = loadConfig();
+        return cfg.catalog !== 'false';
+    }
+    writeFace(faceData, description) {
+        if (!this.isEnabled())
+            return;
+        try {
+            const username = faceData.id;
+            const dir = path.join(CATALOG_DIR, username);
+            fs.mkdirSync(dir, { recursive: true });
+            const filePath = path.join(dir, 'FACE.md');
+            let existingBody = DEFAULT_BODY;
+            let existingDescription;
+            if (fs.existsSync(filePath)) {
+                const existing = fs.readFileSync(filePath, 'utf8');
+                const parsed = parseFrontmatter(existing);
+                if (parsed.body.trim())
+                    existingBody = parsed.body;
+                if (parsed.frontmatter?.description)
+                    existingDescription = parsed.frontmatter.description;
+            }
+            const fm = {
+                name: faceData.name,
+                facename: username,
+            };
+            if (description) {
+                fm.description = description;
+            }
+            else if (existingDescription) {
+                fm.description = existingDescription;
+            }
+            if (faceData.basic_facts && Object.keys(faceData.basic_facts).length > 0) {
+                const attrs = {};
+                for (const [k, v] of Object.entries(faceData.basic_facts)) {
+                    attrs[k] = typeof v === 'object' && v !== null && 'value' in v ? v.value : String(v);
+                }
+                fm.attributes = attrs;
+            }
+            if (faceData.component_counts)
+                fm.component_counts = faceData.component_counts;
+            if (faceData.profile_token_count)
+                fm.profile_token_count = faceData.profile_token_count;
+            const content = serializeFrontmatter(fm) + '\n' + existingBody;
+            fs.writeFileSync(filePath, content);
+            this.rebuildIndex();
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`warn: catalog write failed: ${msg}\n`);
+        }
+    }
+    deleteFace(username) {
+        if (!this.isEnabled())
+            return;
+        try {
+            const dir = path.join(CATALOG_DIR, username);
+            fs.rmSync(dir, { recursive: true, force: true });
+            this.rebuildIndex();
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`warn: catalog delete failed: ${msg}\n`);
+        }
+    }
+    rebuildIndex() {
+        if (!this.isEnabled())
+            return;
+        try {
+            fs.mkdirSync(CATALOG_DIR, { recursive: true });
+            const entries = [];
+            const dirs = fs.readdirSync(CATALOG_DIR, { withFileTypes: true });
+            for (const dirent of dirs) {
+                if (!dirent.isDirectory())
+                    continue;
+                const faceMdPath = path.join(CATALOG_DIR, dirent.name, 'FACE.md');
+                if (!fs.existsSync(faceMdPath))
+                    continue;
+                const content = fs.readFileSync(faceMdPath, 'utf8');
+                const { frontmatter } = parseFrontmatter(content);
+                if (frontmatter)
+                    entries.push(frontmatter);
+            }
+            fs.writeFileSync(CATALOG_INDEX, JSON.stringify(entries, null, 2));
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`warn: catalog index rebuild failed: ${msg}\n`);
+        }
+    }
+}

package/dist/client.js

@@ -41,7 +41,8 @@ export class FacesClient {
         let msg = resp.statusText;
         try {
             const body = await resp.json();
-            msg = String(body.detail ?? body.error ?? body.message ?? msg);
+            const raw = body.detail ?? body.error ?? body.message ?? msg;
+            msg = typeof raw === 'object' ? JSON.stringify(raw) : String(raw);
         }
         catch {
             // use statusText

package/dist/commands/auth/whoami.js

@@ -10,7 +10,7 @@ export default class AuthWhoami extends BaseCommand {
         const client = this.makeClient(flags);
         let data;
         try {
-            data = await client.get('/v1/auth/me', { requireJwt: true });
+            data = await client.get('/auth/me', { requireJwt: true });
         }
         catch (err) {
             if (err instanceof FacesAPIError)

package/dist/commands/billing/checkout.js

@@ -6,9 +6,9 @@ export default class BillingCheckout extends BaseCommand {
     static flags = {
         ...BaseCommand.baseFlags,
         plan: Flags.string({
-            description: 'Plan to upgrade to',
-            options: ['standard', 'pro'],
-            required: true,
+            description: 'Plan to subscribe to',
+            options: ['connect'],
+            default: 'connect',
         }),
     };
     async run() {

package/dist/commands/catalog/doctor.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../../base.js';
+export default class CatalogDoctor extends BaseCommand {
+    static description: string;
+    static flags: {
+        fix: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        generate: 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>;
+    };
+    run(): Promise<unknown>;
+}

package/dist/commands/catalog/doctor.js

@@ -0,0 +1,196 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../base.js';
+import { FacesAPIError } from '../../client.js';
+import { loadConfig } from '../../config.js';
+import { CatalogService, CATALOG_DIR } from '../../catalog.js';
+export default class CatalogDoctor extends BaseCommand {
+    static description = 'Diagnose and repair the local face catalog';
+    static flags = {
+        ...BaseCommand.baseFlags,
+        fix: Flags.boolean({ description: 'Rebuild missing or stale catalog entries from API', default: false }),
+        generate: Flags.boolean({ description: 'Fix + generate missing descriptions via LLM', default: false }),
+    };
+    async run() {
+        const { flags } = await this.parse(CatalogDoctor);
+        const client = this.makeClient(flags);
+        const catalog = new CatalogService();
+        // Fetch all faces from API
+        let remoteFaces;
+        try {
+            const resp = await client.get('/v1/faces');
+            const arr = resp.data ?? resp;
+            // List endpoint returns minimal fields; fetch full details for each
+            remoteFaces = await Promise.all(arr.map(async (f) => {
+                try {
+                    return await client.get(`/v1/faces/${f.id}`);
+                }
+                catch {
+                    return { ...f, uid: f.id };
+                }
+            }));
+        }
+        catch (err) {
+            if (err instanceof FacesAPIError)
+                this.error(`Error (${err.statusCode}): ${err.message}`);
+            throw err;
+        }
+        // Build map of remote faces by username
+        const remoteByUsername = new Map();
+        for (const f of remoteFaces) {
+            remoteByUsername.set(f.id, f);
+        }
+        // Read local catalog
+        const localUsernames = new Set();
+        const localFrontmatters = new Map();
+        try {
+            if (fs.existsSync(CATALOG_DIR)) {
+                for (const dirent of fs.readdirSync(CATALOG_DIR, { withFileTypes: true })) {
+                    if (!dirent.isDirectory())
+                        continue;
+                    localUsernames.add(dirent.name);
+                    const faceMdPath = path.join(CATALOG_DIR, dirent.name, 'FACE.md');
+                    if (fs.existsSync(faceMdPath)) {
+                        const content = fs.readFileSync(faceMdPath, 'utf8');
+                        const match = content.match(/^---\n([\s\S]*?)\n---/);
+                        if (match) {
+                            // Quick parse for name and description
+                            const fm = { facename: dirent.name };
+                            for (const line of match[1].split('\n')) {
+                                if (line.startsWith('  '))
+                                    continue;
+                                const ci = line.indexOf(':');
+                                if (ci < 0)
+                                    continue;
+                                const k = line.slice(0, ci).trim();
+                                const v = line.slice(ci + 1).trim().replace(/^"(.*)"$/, '$1');
+                                if (k === 'name')
+                                    fm.name = v;
+                                if (k === 'description')
+                                    fm.description = v;
+                            }
+                            if (fm.name)
+                                localFrontmatters.set(dirent.name, fm);
+                        }
+                    }
+                }
+            }
+        }
+        catch { /* continue with what we have */ }
+        // Compute diffs
+        const missing = [];
+        const stale = [];
+        const noDescription = [];
+        const orphaned = [];
+        for (const [username, remote] of remoteByUsername) {
+            if (!localUsernames.has(username)) {
+                missing.push(remote);
+            }
+            else {
+                const local = localFrontmatters.get(username);
+                if (local && local.name !== remote.name) {
+                    stale.push(remote);
+                }
+            }
+            const local = localFrontmatters.get(username);
+            if (!local?.description)
+                noDescription.push(username);
+        }
+        for (const username of localUsernames) {
+            if (!remoteByUsername.has(username))
+                orphaned.push(username);
+        }
+        const doFix = flags.fix || flags.generate;
+        if (!doFix) {
+            // Diagnostic mode
+            const issues = [];
+            if (missing.length > 0)
+                issues.push(`${missing.length} face(s) missing from catalog`);
+            if (stale.length > 0)
+                issues.push(`${stale.length} face(s) out of sync`);
+            if (orphaned.length > 0)
+                issues.push(`${orphaned.length} orphaned catalog entries (face deleted on server)`);
+            if (noDescription.length > 0)
+                issues.push(`${noDescription.length} face(s) without a description`);
+            if (issues.length === 0) {
+                this.log('Catalog is healthy.');
+            }
+            else {
+                for (const issue of issues)
+                    this.log(issue);
+                this.log('');
+                this.log('Run faces catalog:doctor --fix to repair catalog');
+                if (noDescription.length > 0) {
+                    this.log('Run faces catalog:doctor --generate to also create missing descriptions');
+                }
+            }
+            return { missing: missing.length, stale: stale.length, orphaned: orphaned.length, noDescription: noDescription.length };
+        }
+        // Fix mode: rebuild missing and stale entries
+        let fixed = 0;
+        for (const face of [...missing, ...stale]) {
+            catalog.writeFace(face);
+            fixed++;
+        }
+        // Also refresh faces that exist but might have stale attributes
+        for (const [username, remote] of remoteByUsername) {
+            if (!missing.some((f) => f.id === username) && !stale.some((f) => f.id === username)) {
+                // Face exists locally and name matches — still refresh attributes
+                catalog.writeFace(remote);
+            }
+        }
+        // Remove orphans
+        let removed = 0;
+        for (const username of orphaned) {
+            catalog.deleteFace(username);
+            removed++;
+        }
+        this.log(`Fixed ${fixed} catalog entries, removed ${removed} orphans.`);
+        // Generate mode: create missing descriptions
+        if (flags.generate && noDescription.length > 0) {
+            const cfg = loadConfig();
+            const catalogModel = cfg.catalog_model ?? 'gpt-5-nano';
+            this.log(`Generating descriptions for ${noDescription.length} face(s) via ${catalogModel}...`);
+            let generated = 0;
+            for (const username of noDescription) {
+                const remote = remoteByUsername.get(username);
+                if (!remote)
+                    continue;
+                try {
+                    const prompt = 'Describe yourself in one paragraph. Who are you, what do you care about, and what kind of questions are you best suited to answer?';
+                    const faceModel = `${username}@${catalogModel}`;
+                    const isAnthropic = catalogModel.startsWith('claude');
+                    let text;
+                    if (isAnthropic) {
+                        const resp = await client.post('/v1/messages', {
+                            body: { model: faceModel, messages: [{ role: 'user', content: prompt }], max_tokens: 256 },
+                        });
+                        text = resp.content?.find((b) => b.type === 'text')?.text;
+                    }
+                    else {
+                        const resp = await client.post('/v1/chat/completions', {
+                            body: { model: faceModel, messages: [{ role: 'user', content: prompt }], max_tokens: 256 },
+                        });
+                        text = resp.choices?.[0]?.message?.content;
+                    }
+                    if (text) {
+                        catalog.writeFace(remote, text.trim());
+                        generated++;
+                        this.log(`  ${username}: done`);
+                    }
+                    else {
+                        this.log(`  ${username}: no response`);
+                    }
+                }
+                catch (err) {
+                    const msg = err instanceof FacesAPIError ? `Error (${err.statusCode}): ${err.message}` : String(err);
+                    this.log(`  ${username}: failed — ${msg}`);
+                }
+            }
+            this.log(`Generated ${generated} description(s).`);
+        }
+        catalog.rebuildIndex();
+        return { fixed, removed, generated: flags.generate ? noDescription.length : 0 };
+    }
+}

package/dist/commands/catalog/list.d.ts

@@ -0,0 +1,10 @@
+import { BaseCommand } from '../../base.js';
+export default class CatalogList extends BaseCommand {
+    static description: string;
+    static flags: {
+        '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>;
+    };
+    run(): Promise<unknown>;
+}

package/dist/commands/catalog/list.js

@@ -0,0 +1,35 @@
+import fs from 'node:fs';
+import { BaseCommand } from '../../base.js';
+import { CATALOG_INDEX } from '../../catalog.js';
+export default class CatalogList extends BaseCommand {
+    static description = 'List all faces in the local catalog';
+    static flags = {
+        ...BaseCommand.baseFlags,
+    };
+    async run() {
+        let entries = [];
+        try {
+            if (fs.existsSync(CATALOG_INDEX)) {
+                entries = JSON.parse(fs.readFileSync(CATALOG_INDEX, 'utf8'));
+            }
+        }
+        catch {
+            this.error('Could not read catalog.json');
+        }
+        if (this.jsonEnabled())
+            return entries;
+        if (entries.length === 0) {
+            this.log('(no faces in catalog — run faces catalog:doctor --fix)');
+            return entries;
+        }
+        const nameWidth = Math.max(...entries.map((e) => String(e.facename ?? '').length));
+        const displayWidth = Math.max(...entries.map((e) => String(e.name ?? '').length));
+        for (const e of entries) {
+            const facename = String(e.facename ?? '').padEnd(nameWidth);
+            const name = String(e.name ?? '').padEnd(displayWidth);
+            const desc = e.description ? `  ${String(e.description).slice(0, 60)}...` : '';
+            this.log(`${facename}  ${name}${desc}`);
+        }
+        return entries;
+    }
+}

package/dist/commands/chat/chat.d.ts

@@ -9,6 +9,7 @@ export default class ChatChat extends BaseCommand {
         'max-tokens': import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
         temperature: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         file: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        responses: 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>;
@@ -17,4 +18,7 @@ export default class ChatChat extends BaseCommand {
         face_username: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
     run(): Promise<unknown>;
+    private runChatCompletions;
+    private runMessages;
+    private runResponses;
 }