faces-cli 1.6.2 → 1.6.3

package/dist/catalog.d.ts

@@ -5,21 +5,30 @@ export interface FaceFrontmatter {
     description?: string;
     alias: string;
     attributes?: Record<string, string>;
+    tags?: string[];
+    default_model?: string;
+    formula?: string | null;
     component_counts?: {
         alpha: number;
         beta: number;
         delta: number;
         epsilon: number;
     };
+    compiled_tokens?: number;
     profile_token_count?: number;
+    [key: string]: unknown;
 }
 export interface FaceDataInput {
     name: string;
     alias: string;
     uid?: string;
+    description?: string | null;
     basic_facts?: Record<string, string | {
         value: string;
     }> | null;
+    tags?: string[] | null;
+    default_model?: string | null;
+    formula?: string | null;
     component_counts?: {
         alpha: number;
         beta: number;
@@ -27,10 +36,13 @@ export interface FaceDataInput {
         epsilon: number;
     } | null;
     profile_token_count?: number | null;
+    total_tokens_saved?: number | null;
 }
 export declare class CatalogService {
     isEnabled(): boolean;
     writeFace(faceData: FaceDataInput, description?: string): void;
-    deleteFace(username: string): void;
+    deleteFace(alias: string): void;
+    /** Update just tags on an existing FACE.md without touching other fields */
+    updateTags(alias: string, tags: string[]): void;
     rebuildIndex(): void;
 }

package/dist/catalog.js

@@ -5,7 +5,7 @@ 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 === '') {
+    if (/[:#\[\]{}&*!|>'"%@`\n]/.test(value) || value !== value.trim() || value === '') {
         return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
     }
     return value;
@@ -16,16 +16,26 @@ function serializeFrontmatter(fm) {
     if (fm.description)
         lines.push(`description: ${quoteYaml(fm.description)}`);
     lines.push(`alias: ${quoteYaml(fm.alias)}`);
+    if (fm.default_model)
+        lines.push(`default_model: ${quoteYaml(fm.default_model)}`);
+    if (fm.formula)
+        lines.push(`formula: ${quoteYaml(fm.formula)}`);
     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.tags && fm.tags.length > 0) {
+        lines.push(`tags: [${fm.tags.join(', ')}]`);
+    }
     if (fm.component_counts) {
         const cc = fm.component_counts;
         lines.push(`component_counts: ${cc.alpha + cc.beta + cc.delta + cc.epsilon}`);
     }
+    if (fm.compiled_tokens) {
+        lines.push(`compiled_tokens: ${fm.compiled_tokens}`);
+    }
     if (fm.profile_token_count) {
         lines.push(`profile_token_count: ${fm.profile_token_count}`);
     }
@@ -35,12 +45,14 @@ function serializeFrontmatter(fm) {
 function parseFrontmatter(content) {
     const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
     if (!match)
-        return { frontmatter: null, body: content };
+        return { frontmatter: null, body: content, extraKeys: {} };
     const yamlBlock = match[1];
     const body = match[2];
     const fm = {};
+    const extraKeys = {};
     let inAttributes = false;
     const attributes = {};
+    const knownKeys = new Set(['name', 'description', 'alias', 'attributes', 'tags', 'default_model', 'formula', 'component_counts', 'compiled_tokens', 'profile_token_count']);
     for (const line of yamlBlock.split('\n')) {
         if (line.startsWith('  ') && inAttributes) {
             const colonIdx = line.indexOf(':');
@@ -63,14 +75,30 @@ function parseFrontmatter(content) {
             fm.description = val;
         else if (key === 'alias')
             fm.alias = val;
+        else if (key === 'default_model')
+            fm.default_model = val;
+        else if (key === 'formula')
+            fm.formula = val;
         else if (key === 'attributes')
             inAttributes = true;
+        else if (key === 'tags') {
+            const inner = val.replace(/^\[/, '').replace(/\]$/, '');
+            fm.tags = inner ? inner.split(',').map(s => s.trim()).filter(Boolean) : [];
+        }
+        else if (key === 'compiled_tokens')
+            fm.compiled_tokens = Number(val) || undefined;
+        else if (key === 'profile_token_count')
+            fm.profile_token_count = Number(val) || undefined;
+        else if (!knownKeys.has(key)) {
+            // Preserve agent/user-managed keys
+            extraKeys[key] = val;
+        }
     }
     if (Object.keys(attributes).length > 0)
         fm.attributes = attributes;
     if (!fm.name || !fm.alias)
-        return { frontmatter: null, body: content };
-    return { frontmatter: fm, body };
+        return { frontmatter: null, body: content, extraKeys: {} };
+    return { frontmatter: fm, body, extraKeys };
 }
 const DEFAULT_BODY = '\n## Notes\n\n';
 export class CatalogService {
@@ -82,12 +110,13 @@ export class CatalogService {
         if (!this.isEnabled())
             return;
         try {
-            const username = faceData.alias;
-            const dir = path.join(CATALOG_DIR, username);
+            const alias = faceData.alias;
+            const dir = path.join(CATALOG_DIR, alias);
             fs.mkdirSync(dir, { recursive: true });
             const filePath = path.join(dir, 'FACE.md');
             let existingBody = DEFAULT_BODY;
             let existingDescription;
+            let existingExtraKeys = {};
             if (fs.existsSync(filePath)) {
                 const existing = fs.readFileSync(filePath, 'utf8');
                 const parsed = parseFrontmatter(existing);
@@ -95,17 +124,26 @@ export class CatalogService {
                     existingBody = parsed.body;
                 if (parsed.frontmatter?.description)
                     existingDescription = parsed.frontmatter.description;
+                existingExtraKeys = parsed.extraKeys;
             }
             const fm = {
                 name: faceData.name,
-                alias: username,
+                alias,
             };
+            // Description: explicit arg > existing > API response
             if (description) {
                 fm.description = description;
             }
+            else if (faceData.description) {
+                fm.description = faceData.description;
+            }
             else if (existingDescription) {
                 fm.description = existingDescription;
             }
+            if (faceData.default_model)
+                fm.default_model = faceData.default_model;
+            if (faceData.formula)
+                fm.formula = faceData.formula;
             if (faceData.basic_facts && Object.keys(faceData.basic_facts).length > 0) {
                 const attrs = {};
                 for (const [k, v] of Object.entries(faceData.basic_facts)) {
@@ -113,10 +151,19 @@ export class CatalogService {
                 }
                 fm.attributes = attrs;
             }
+            if (faceData.tags && faceData.tags.length > 0)
+                fm.tags = faceData.tags;
             if (faceData.component_counts)
                 fm.component_counts = faceData.component_counts;
             if (faceData.profile_token_count)
                 fm.profile_token_count = faceData.profile_token_count;
+            if (faceData.total_tokens_saved)
+                fm.compiled_tokens = faceData.total_tokens_saved;
+            // Preserve agent/user-managed extra keys
+            for (const [k, v] of Object.entries(existingExtraKeys)) {
+                if (!(k in fm))
+                    fm[k] = v;
+            }
             const content = serializeFrontmatter(fm) + '\n' + existingBody;
             fs.writeFileSync(filePath, content);
             this.rebuildIndex();
@@ -126,11 +173,11 @@ export class CatalogService {
             process.stderr.write(`warn: catalog write failed: ${msg}\n`);
         }
     }
-    deleteFace(username) {
+    deleteFace(alias) {
         if (!this.isEnabled())
             return;
         try {
-            const dir = path.join(CATALOG_DIR, username);
+            const dir = path.join(CATALOG_DIR, alias);
             fs.rmSync(dir, { recursive: true, force: true });
             this.rebuildIndex();
         }
@@ -139,6 +186,28 @@ export class CatalogService {
             process.stderr.write(`warn: catalog delete failed: ${msg}\n`);
         }
     }
+    /** Update just tags on an existing FACE.md without touching other fields */
+    updateTags(alias, tags) {
+        if (!this.isEnabled())
+            return;
+        try {
+            const filePath = path.join(CATALOG_DIR, alias, 'FACE.md');
+            if (!fs.existsSync(filePath))
+                return;
+            const content = fs.readFileSync(filePath, 'utf8');
+            const parsed = parseFrontmatter(content);
+            if (!parsed.frontmatter)
+                return;
+            parsed.frontmatter.tags = tags;
+            const newContent = serializeFrontmatter(parsed.frontmatter) + '\n' + parsed.body;
+            fs.writeFileSync(filePath, newContent);
+            this.rebuildIndex();
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`warn: catalog tag update failed: ${msg}\n`);
+        }
+    }
     rebuildIndex() {
         if (!this.isEnabled())
             return;

package/dist/commands/catalog/backup.js

@@ -3,7 +3,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { BaseCommand } from '../../base.js';
 import { FacesAPIError } from '../../client.js';
-import { flattenBasicFacts } from '../../utils.js';
+import { flattenAttributes } from '../../utils.js';
 export default class CatalogBackup extends BaseCommand {
     static description = 'Snapshot all faces, teams, and source material for migration';
     static flags = {
@@ -13,10 +13,10 @@ export default class CatalogBackup extends BaseCommand {
         const { flags } = await this.parse(CatalogBackup);
         const client = this.makeClient(flags);
         const json = this.jsonEnabled();
-        // Fetch all faces
+        // Fetch all faces with tags included
         let faces;
         try {
-            const resp = await client.get('/v1/faces');
+            const resp = await client.get('/v1/faces?include=tags');
             faces = (resp.data ?? resp);
         }
         catch (err) {
@@ -31,27 +31,16 @@ export default class CatalogBackup extends BaseCommand {
             const alias = face.alias;
             if (!json)
                 process.stderr.write(`  ${alias}: `);
-            // Fetch full face details (list endpoint may omit description)
-            let fullFace = face;
-            try {
-                fullFace = await client.get(`/v1/faces/${alias}`);
-            }
-            catch { /* use list data */ }
-            // Fetch tags
-            let tags = [];
-            try {
-                const tagResp = await client.get(`/v1/iam/${alias}/tags`);
-                tags = tagResp.tags ?? [];
-            }
-            catch { /* no tags */ }
+            // Tags and description come from the enriched list response
+            const tags = face.tags ?? [];
             const entry = {
                 alias,
-                name: fullFace.name,
-                description: fullFace.description ?? null,
-                basic_facts: fullFace.basic_facts ? flattenBasicFacts(fullFace.basic_facts) : null,
-                default_model: fullFace.default_model ?? null,
-                default_tools: fullFace.default_tools ?? [],
-                formula: fullFace.formula ?? null,
+                name: face.name,
+                description: face.description ?? null,
+                basic_facts: face.basic_facts ? flattenAttributes(face.basic_facts) : null,
+                default_model: face.default_model ?? null,
+                default_tools: face.default_tools ?? [],
+                formula: face.formula ?? null,
                 tags,
                 documents: [],
                 threads: [],
@@ -91,18 +80,10 @@ export default class CatalogBackup extends BaseCommand {
         }
         // Fetch teams
         const backupTeams = [];
-        let username;
-        try {
-            const resp = await client.get('/auth/me');
-            const whoami = (resp.data ?? resp);
-            username = whoami.username ?? undefined;
-        }
-        catch { /* proceed */ }
         try {
             const resp = await client.get('/v1/me/teams');
             let teams = resp.data ?? resp;
-            if (username)
-                teams = teams.filter(t => t.name !== username);
+            teams = teams.filter(t => t.kind !== 'personal');
             for (const team of teams) {
                 const teamId = team.id;
                 if (!json)

package/dist/commands/catalog/doctor.js

@@ -5,8 +5,9 @@ import { BaseCommand } from '../../base.js';
 import { FacesAPIError } from '../../client.js';
 import { loadConfig } from '../../config.js';
 import { CatalogService, CATALOG_DIR } from '../../catalog.js';
+import { TeamCatalogService } from '../../team-catalog.js';
 export default class CatalogDoctor extends BaseCommand {
-    static description = 'Diagnose and repair the local face catalog';
+    static description = 'Diagnose and repair the local face and team catalog';
     static flags = {
         ...BaseCommand.baseFlags,
         fix: Flags.boolean({ description: 'Rebuild missing or stale catalog entries from API', default: false }),
@@ -16,15 +17,17 @@ export default class CatalogDoctor extends BaseCommand {
         const { flags } = await this.parse(CatalogDoctor);
         const client = this.makeClient(flags);
         const catalog = new CatalogService();
-        // Fetch all faces from API
+        const teamCatalog = new TeamCatalogService();
+        // Fetch all faces from API (with tags)
         let remoteFaces;
         try {
-            const resp = await client.get('/v1/faces');
+            const resp = await client.get('/v1/faces?include=tags');
             const arr = resp.data ?? resp;
-            // List endpoint returns minimal fields; fetch full details for each
+            // Fetch full details for each face (tags come from list, but need description etc.)
             remoteFaces = await Promise.all(arr.map(async (f) => {
                 try {
-                    return await client.get(`/v1/faces/${f.alias}`);
+                    const full = await client.get(`/v1/faces/${f.alias}?include=tags`);
+                    return full;
                 }
                 catch {
                     return { ...f, uid: f.alias };
@@ -55,7 +58,6 @@ export default class CatalogDoctor extends BaseCommand {
                         const content = fs.readFileSync(faceMdPath, 'utf8');
                         const match = content.match(/^---\n([\s\S]*?)\n---/);
                         if (match) {
-                            // Quick parse for name and description
                             const fm = { alias: dirent.name };
                             for (const line of match[1].split('\n')) {
                                 if (line.startsWith('  '))
@@ -78,7 +80,7 @@ export default class CatalogDoctor extends BaseCommand {
             }
         }
         catch { /* continue with what we have */ }
-        // Compute diffs
+        // Compute face diffs
         const missing = [];
         const stale = [];
         const noDescription = [];
@@ -101,9 +103,21 @@ export default class CatalogDoctor extends BaseCommand {
             if (!remoteByAlias.has(alias))
                 orphaned.push(alias);
         }
+        // Check teams
+        let remoteTeams = [];
+        const localTeamNames = new Set(teamCatalog.listTeams());
+        try {
+            const resp = await client.get('/v1/me/teams');
+            remoteTeams = (resp.data ?? resp)
+                .filter(t => t.kind !== 'personal');
+        }
+        catch { /* proceed */ }
+        const missingTeams = remoteTeams.filter(t => {
+            const slug = String(t.name).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+            return !localTeamNames.has(slug);
+        });
         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`);
@@ -113,6 +127,8 @@ export default class CatalogDoctor extends BaseCommand {
                 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 (missingTeams.length > 0)
+                issues.push(`${missingTeams.length} team(s) missing from local catalog`);
             if (issues.length === 0) {
                 this.log('Catalog is healthy.');
             }
@@ -125,28 +141,63 @@ export default class CatalogDoctor extends BaseCommand {
                     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 };
+            return { missing: missing.length, stale: stale.length, orphaned: orphaned.length, noDescription: noDescription.length, missingTeams: missingTeams.length };
         }
-        // Fix mode: rebuild missing and stale entries
+        // Fix mode: rebuild face entries
         let fixed = 0;
         for (const face of [...missing, ...stale]) {
-            catalog.writeFace(face, face.description ?? undefined);
+            catalog.writeFace(face);
             fixed++;
         }
-        // Also refresh faces that exist but might have stale attributes
+        // Refresh all existing faces (attributes, tags, description)
         for (const [alias, remote] of remoteByAlias) {
             if (!missing.some((f) => f.alias === alias) && !stale.some((f) => f.alias === alias)) {
-                // Face exists locally and name matches — still refresh attributes and description
-                catalog.writeFace(remote, remote.description ?? undefined);
+                catalog.writeFace(remote);
             }
         }
-        // Remove orphans
+        // Remove orphaned faces
         let removed = 0;
         for (const alias of orphaned) {
             catalog.deleteFace(alias);
             removed++;
         }
-        this.log(`Fixed ${fixed} catalog entries, removed ${removed} orphans.`);
+        // Sync teams
+        let teamsSynced = 0;
+        // Build uid→alias map for member resolution
+        const uidToAlias = new Map();
+        for (const f of remoteFaces) {
+            if (f.uid)
+                uidToAlias.set(f.uid, f.alias);
+        }
+        for (const team of remoteTeams) {
+            const teamId = team.id;
+            const slug = String(team.name).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+            // Fetch members and tags
+            let memberAliases = [];
+            try {
+                const membersResp = await client.get(`/v1/teams/${teamId}/members`);
+                memberAliases = (membersResp.data ?? []).map(m => {
+                    const iamId = m.iam_id;
+                    return uidToAlias.get(iamId) ?? iamId;
+                });
+            }
+            catch { /* proceed */ }
+            let tags = [];
+            try {
+                const tagResp = await client.get(`/v1/teams/${teamId}/tags`);
+                tags = tagResp.tags ?? [];
+            }
+            catch { /* proceed */ }
+            teamCatalog.writeTeam(slug, {
+                id: teamId,
+                name: team.name,
+                description: team.description ?? undefined,
+                tags,
+                members: memberAliases,
+            }, team.protocol ?? undefined);
+            teamsSynced++;
+        }
+        this.log(`Fixed ${fixed} face(s), removed ${removed} orphan(s), synced ${teamsSynced} team(s).`);
         // Generate mode: create missing descriptions
         if (flags.generate && noDescription.length > 0) {
             const cfg = loadConfig();
@@ -176,8 +227,7 @@ export default class CatalogDoctor extends BaseCommand {
                     }
                     if (text) {
                         const desc = text.trim();
-                        catalog.writeFace(remote, desc);
-                        // Also sync description to server
+                        catalog.writeFace({ ...remote, description: desc });
                         try {
                             await client.patch(`/v1/faces/${alias}`, { body: { description: desc } });
                         }
@@ -197,6 +247,6 @@ export default class CatalogDoctor extends BaseCommand {
             this.log(`Generated ${generated} description(s).`);
         }
         catalog.rebuildIndex();
-        return { fixed, removed, generated: flags.generate ? noDescription.length : 0 };
+        return { fixed, removed, teamsSynced, generated: flags.generate ? noDescription.length : 0 };
     }
 }

package/dist/commands/face/create.js

@@ -2,7 +2,7 @@ import { Flags } from '@oclif/core';
 import { BaseCommand } from '../../base.js';
 import { FacesAPIError } from '../../client.js';
 import { CatalogService } from '../../catalog.js';
-import { flattenBasicFacts } from '../../utils.js';
+import { renameFaceFields } from '../../utils.js';
 export default class FaceCreate extends BaseCommand {
     static description = 'Create a new face';
     static flags = {
@@ -60,22 +60,31 @@ export default class FaceCreate extends BaseCommand {
             for (const w of face.warnings)
                 this.warn(w);
         }
-        if (face.basic_facts && typeof face.basic_facts === 'object') {
-            face.basic_facts = flattenBasicFacts(face.basic_facts);
-        }
         // Post tags if provided
-        if (flags.tag && flags.tag.length > 0) {
+        const tags = flags.tag ?? [];
+        if (tags.length > 0) {
             try {
-                await client.post(`/v1/iam/${flags.alias}/tags`, { body: { tags: flags.tag } });
+                await client.post(`/v1/iam/${flags.alias}/tags`, { body: { tags } });
+                face.tags = tags;
             }
             catch (err) {
                 if (err instanceof FacesAPIError)
                     this.warn(`Tags failed (${err.statusCode}): ${err.message}`);
             }
         }
+        // Rename basic_facts → attributes in response
+        renameFaceFields(face);
+        // Write to local catalog with tags
         try {
             const catalog = new CatalogService();
-            catalog.writeFace(face, flags.description);
+            catalog.writeFace({
+                ...face,
+                basic_facts: face.attributes,
+                tags: face.tags ?? undefined,
+                description: face.description ?? flags.description ?? undefined,
+                default_model: face.default_model,
+                formula: face.formula,
+            });
         }
         catch { /* catalog errors are non-fatal */ }
         if (!this.jsonEnabled())

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

@@ -2,6 +2,7 @@ import { BaseCommand } from '../../base.js';
 export default class FaceGet extends BaseCommand {
     static description: string;
     static flags: {
+        include: 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>;

package/dist/commands/face/get.js

@@ -1,11 +1,12 @@
-import { Args } from '@oclif/core';
+import { Args, Flags } from '@oclif/core';
 import { BaseCommand } from '../../base.js';
 import { FacesAPIError } from '../../client.js';
-import { flattenBasicFacts } from '../../utils.js';
+import { renameFaceFields } from '../../utils.js';
 export default class FaceGet extends BaseCommand {
     static description = 'Get details for a face by alias';
     static flags = {
         ...BaseCommand.baseFlags,
+        include: Flags.string({ description: 'Include extra fields: tags, teams (comma-separated)' }),
     };
     static args = {
         face_id: Args.string({ description: 'Face alias', required: true }),
@@ -13,18 +14,21 @@ export default class FaceGet extends BaseCommand {
     async run() {
         const { args, flags } = await this.parse(FaceGet);
         const client = this.makeClient(flags);
+        const path = flags.include
+            ? `/v1/faces/${args.face_id}?include=${encodeURIComponent(flags.include)}`
+            : `/v1/faces/${args.face_id}`;
         let data;
         try {
-            data = await client.get(`/v1/faces/${args.face_id}`);
+            data = await client.get(path);
         }
         catch (err) {
             if (err instanceof FacesAPIError)
                 this.error(`Error (${err.statusCode}): ${err.message}`);
             throw err;
         }
-        const f = data;
-        if (f.basic_facts)
-            f.basic_facts = flattenBasicFacts(f.basic_facts);
+        const face = data;
+        renameFaceFields(face);
+        const f = face;
         if (!this.jsonEnabled()) {
             this.log(`alias:     ${f.alias}`);
             this.log(`uid:       ${f.uid}`);
@@ -37,9 +41,9 @@ export default class FaceGet extends BaseCommand {
             }
             else {
                 this.log(`type:      concrete`);
-                if (f.basic_facts && Object.keys(f.basic_facts).length > 0) {
-                    this.log('basic_facts:');
-                    for (const [k, v] of Object.entries(f.basic_facts)) {
+                if (f.attributes && Object.keys(f.attributes).length > 0) {
+                    this.log('attributes:');
+                    for (const [k, v] of Object.entries(f.attributes)) {
                         this.log(`  ${k}: ${v}`);
                     }
                 }

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

@@ -3,6 +3,8 @@ export default class FaceList extends BaseCommand {
     static description: string;
     static flags: {
         tag: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        team: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        include: 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>;

package/dist/commands/face/list.js

@@ -1,26 +1,33 @@
 import { Flags } from '@oclif/core';
 import { BaseCommand } from '../../base.js';
 import { FacesAPIError } from '../../client.js';
-import { flattenBasicFacts } from '../../utils.js';
+import { renameFaceFields } from '../../utils.js';
 export default class FaceList extends BaseCommand {
     static description = 'List all owned faces';
     static flags = {
         ...BaseCommand.baseFlags,
         tag: Flags.string({ description: 'Filter by tag (repeatable, AND logic)', multiple: true }),
+        team: Flags.string({ description: 'Filter by team ID (repeatable, OR logic)', multiple: true }),
+        include: Flags.string({ description: 'Include extra fields: tags, teams (comma-separated)' }),
     };
     async run() {
         const { flags } = await this.parse(FaceList);
         const client = this.makeClient(flags);
-        const params = {};
-        // Tags need to be passed as repeated query params: ?tag=a&tag=b
-        // Build the query string manually since URLSearchParams dedupes keys
-        let tagQuery = '';
+        // Build query string manually for repeated params
+        const parts = [];
         if (flags.tag && flags.tag.length > 0) {
-            tagQuery = flags.tag.map(t => `tag=${encodeURIComponent(t)}`).join('&');
+            for (const t of flags.tag)
+                parts.push(`tag=${encodeURIComponent(t)}`);
         }
+        if (flags.team && flags.team.length > 0) {
+            for (const t of flags.team)
+                parts.push(`team_id=${encodeURIComponent(t)}`);
+        }
+        if (flags.include)
+            parts.push(`include=${encodeURIComponent(flags.include)}`);
         let data;
         try {
-            const path = tagQuery ? `/v1/faces?${tagQuery}` : '/v1/faces';
+            const path = parts.length > 0 ? `/v1/faces?${parts.join('&')}` : '/v1/faces';
             data = await client.get(path);
         }
         catch (err) {
@@ -28,12 +35,10 @@ export default class FaceList extends BaseCommand {
                 this.error(`Error (${err.statusCode}): ${err.message}`);
             throw err;
         }
-        // Flatten basic_facts in response
+        // Rename basic_facts → attributes in response
         const raw = data.data ?? data;
         for (const f of raw) {
-            if (f.basic_facts && typeof f.basic_facts === 'object') {
-                f.basic_facts = flattenBasicFacts(f.basic_facts);
-            }
+            renameFaceFields(f);
         }
         if (!this.jsonEnabled()) {
             const faces = raw;