faces-cli 1.5.6 → 1.5.8

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('/auth/me', { requireJwt: true });
+            data = await client.get('/auth/me');
         }
         catch (err) {
             if (err instanceof FacesAPIError)

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

@@ -0,0 +1,18 @@
+import { BaseCommand } from '../../base.js';
+export default class CatalogManyfaced extends BaseCommand {
+    static description: string;
+    static flags: {
+        skill: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        install: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'skills-dir': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        refresh: 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>;
+    private fetchIndex;
+    private listSkills;
+    private showSkill;
+    private installSkill;
+}

package/dist/commands/catalog/manyfaced.js

@@ -0,0 +1,225 @@
+import { Flags } from '@oclif/core';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { BaseCommand } from '../../base.js';
+const GITHUB_REPO = 'facessh/manyfaced';
+const GITHUB_API = `https://api.github.com/repos/${GITHUB_REPO}`;
+const CACHE_PATH = path.join(os.homedir(), '.faces', 'manyfaced-index.json');
+const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
+function parseFrontmatter(content) {
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!match)
+        return {};
+    const fm = {};
+    for (const line of match[1].split('\n')) {
+        const ci = line.indexOf(':');
+        if (ci < 0)
+            continue;
+        const key = line.slice(0, ci).trim();
+        const val = line.slice(ci + 1).trim().replace(/^["']|["']$/g, '');
+        if (key && val)
+            fm[key] = val;
+    }
+    return fm;
+}
+async function githubGet(urlPath) {
+    const resp = await fetch(`${GITHUB_API}${urlPath}`, {
+        headers: { Accept: 'application/vnd.github.v3+json', 'User-Agent': 'faces-cli' },
+    });
+    if (!resp.ok) {
+        const body = await resp.text().catch(() => '');
+        throw new Error(`GitHub API ${resp.status}: ${body.slice(0, 200)}`);
+    }
+    return resp.json();
+}
+async function githubGetFile(filePath) {
+    const data = (await githubGet(`/contents/${filePath}`));
+    if (!data.content)
+        throw new Error(`No content for ${filePath}`);
+    return Buffer.from(data.content, 'base64').toString('utf8');
+}
+function loadCache() {
+    try {
+        if (!fs.existsSync(CACHE_PATH))
+            return null;
+        const raw = JSON.parse(fs.readFileSync(CACHE_PATH, 'utf8'));
+        if (Date.now() - raw.fetched_at > CACHE_TTL_MS)
+            return null;
+        return raw;
+    }
+    catch {
+        return null;
+    }
+}
+function saveCache(index) {
+    const dir = path.dirname(CACHE_PATH);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(CACHE_PATH, JSON.stringify(index, null, 2));
+}
+export default class CatalogManyfaced extends BaseCommand {
+    static description = 'Browse and install community manyfaced skills from github.com/facessh/manyfaced';
+    static flags = {
+        ...BaseCommand.baseFlags,
+        skill: Flags.string({ description: 'Show details for a specific skill' }),
+        install: Flags.string({ description: 'Install a skill by name' }),
+        'skills-dir': Flags.string({
+            description: 'Directory to install skills into (required for --install)',
+        }),
+        refresh: Flags.boolean({
+            description: 'Force refresh the skill index (ignore cache)',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(CatalogManyfaced);
+        if (flags.install) {
+            return this.installSkill(flags.install, flags['skills-dir']);
+        }
+        if (flags.skill) {
+            return this.showSkill(flags.skill);
+        }
+        return this.listSkills(flags.refresh);
+    }
+    async fetchIndex(forceRefresh) {
+        if (!forceRefresh) {
+            const cached = loadCache();
+            if (cached)
+                return cached.skills;
+        }
+        const entries = (await githubGet('/contents/'));
+        const dirs = entries.filter((e) => e.type === 'dir' && !e.name.startsWith('.'));
+        const skills = [];
+        for (const dir of dirs) {
+            try {
+                const skillMd = await githubGetFile(`${dir.name}/SKILL.md`);
+                const fm = parseFrontmatter(skillMd);
+                skills.push({
+                    name: dir.name,
+                    description: fm.description || '(no description)',
+                });
+            }
+            catch {
+                skills.push({ name: dir.name, description: '(could not read SKILL.md)' });
+            }
+        }
+        saveCache({ fetched_at: Date.now(), skills });
+        return skills;
+    }
+    async listSkills(refresh) {
+        const skills = await this.fetchIndex(refresh);
+        if (skills.length === 0) {
+            this.log('No manyfaced skills found in the community catalog.');
+            return { skills: [] };
+        }
+        if (this.jsonEnabled())
+            return { skills };
+        const nameWidth = Math.max(30, ...skills.map((s) => s.name.length + 2));
+        this.log('');
+        this.log(`${'NAME'.padEnd(nameWidth)}DESCRIPTION`);
+        this.log(`${'-'.repeat(nameWidth)}${'-'.repeat(50)}`);
+        for (const s of skills) {
+            this.log(`${s.name.padEnd(nameWidth)}${s.description.slice(0, 70)}`);
+        }
+        this.log('');
+        this.log(`${skills.length} skills available. Use --skill NAME for details, --install NAME to install.`);
+        return { skills };
+    }
+    async showSkill(name) {
+        let readme;
+        try {
+            readme = await githubGetFile(`${name}/README.md`);
+        }
+        catch {
+            this.error(`Skill '${name}' not found. Run 'faces catalog:manyfaced' to see available skills.`);
+        }
+        if (this.jsonEnabled()) {
+            let skillMd = '';
+            try {
+                skillMd = await githubGetFile(`${name}/SKILL.md`);
+            }
+            catch { /* ignore */ }
+            const fm = parseFrontmatter(skillMd);
+            return { name, description: fm.description, readme };
+        }
+        this.log('');
+        this.log(readme);
+        return { name, readme };
+    }
+    async installSkill(name, skillsDir) {
+        if (!skillsDir) {
+            this.error('--skills-dir is required for install. Specify where skills should be installed.\n' +
+                'Example: faces catalog:manyfaced --install ' + name + ' --skills-dir ~/.claude/skills');
+        }
+        // Verify skill exists
+        const skills = await this.fetchIndex(false);
+        const found = skills.find((s) => s.name === name);
+        if (!found) {
+            this.error(`Skill '${name}' not found. Available skills:\n` +
+                skills.map((s) => `  ${s.name}`).join('\n'));
+        }
+        // Create skills-dir if needed
+        if (!fs.existsSync(skillsDir)) {
+            fs.mkdirSync(skillsDir, { recursive: true });
+        }
+        const installDir = path.join(skillsDir, name);
+        // Fetch the full directory tree for this skill
+        process.stderr.write(`Fetching ${name}...\n`);
+        const tree = (await githubGet('/git/trees/main?recursive=1'));
+        const skillFiles = tree.tree.filter((f) => f.path.startsWith(`${name}/`) && f.type === 'blob');
+        if (skillFiles.length === 0) {
+            this.error(`No files found for skill '${name}'.`);
+        }
+        // Download and write each file
+        const faceMdFiles = [];
+        for (const file of skillFiles) {
+            const relativePath = file.path.slice(name.length + 1); // remove skill prefix
+            const destPath = path.join(installDir, relativePath);
+            const destDir = path.dirname(destPath);
+            if (!fs.existsSync(destDir))
+                fs.mkdirSync(destDir, { recursive: true });
+            process.stderr.write(`  ${relativePath}\n`);
+            const content = await githubGetFile(file.path);
+            fs.writeFileSync(destPath, content);
+            // Track FACE.md files for catalog copy
+            if (relativePath.endsWith('FACE.md') && relativePath.includes('catalog/')) {
+                faceMdFiles.push(destPath);
+            }
+        }
+        // Copy FACE.md files to local catalog
+        const catalogDir = path.join(os.homedir(), '.faces', 'catalog');
+        const installedFaces = [];
+        for (const faceMdPath of faceMdFiles) {
+            const content = fs.readFileSync(faceMdPath, 'utf8');
+            const fm = parseFrontmatter(content);
+            const alias = fm.alias || fm.facename || path.basename(path.dirname(faceMdPath));
+            const catalogFaceDir = path.join(catalogDir, alias);
+            if (!fs.existsSync(catalogFaceDir))
+                fs.mkdirSync(catalogFaceDir, { recursive: true });
+            fs.writeFileSync(path.join(catalogFaceDir, 'FACE.md'), content);
+            installedFaces.push(alias);
+        }
+        if (!this.jsonEnabled()) {
+            this.log('');
+            this.log(`Installed ${name} to ${installDir}/`);
+            this.log(`  ${skillFiles.length} files written`);
+            if (installedFaces.length > 0) {
+                this.log('');
+                this.log(`Faces added to local catalog (need creation + compilation):`);
+                for (const alias of installedFaces) {
+                    this.log(`  faces face:create --alias ${alias} --name "${alias}"`);
+                }
+                this.log('');
+                this.log('After creating each face, compile source material:');
+                this.log('  faces compile:doc ALIAS --file source.txt');
+            }
+        }
+        return {
+            skill: name,
+            install_dir: installDir,
+            files: skillFiles.length,
+            faces: installedFaces,
+        };
+    }
+}