@eightstate/escli 0.5.0

package/dist/lib/envelope.js

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { EnvelopeSchema } from '@eightstate/contracts/envelope';
+import { ErrorCode } from '@eightstate/contracts/errors';
+import { ExitCodes } from '@eightstate/contracts/exit-codes';
+import { EscliError } from './escli-error.js';
+export function buildErrorEnvelope(command, version, error, durationMs) {
+    const errorObject = {
+        code: error.code,
+        message: error.message,
+        remediation: error.remediation,
+        details: error.details,
+        cause_code: error.causeCode,
+    };
+    return EnvelopeSchema(z.unknown()).parse({ ok: false, data: null, error: errorObject, meta: meta(command, version, durationMs) });
+}
+export function buildUsageError(message, code = ErrorCode.UsageInvalid, details) {
+    return new EscliError(message, { code, exitCode: ExitCodes.Usage, details });
+}
+export function meta(command, version, durationMs) {
+    return {
+        schema_version: '1',
+        escli_version: version,
+        command,
+        warnings: [],
+        duration_ms: durationMs,
+    };
+}
+//# sourceMappingURL=envelope.js.map

package/dist/lib/escli-error.js

@@ -0,0 +1,20 @@
+import { ErrorCode } from '@eightstate/contracts/errors';
+import { exitCodeForErrorCode } from '@eightstate/contracts/failure-taxonomy';
+export class EscliError extends Error {
+    code;
+    exitCode;
+    remediation;
+    details;
+    causeCode;
+    constructor(message, options = {}) {
+        super(message);
+        this.name = 'EscliError';
+        this.code = options.code ?? ErrorCode.Unknown;
+        this.exitCode = options.exitCode ?? exitCodeForErrorCode(this.code);
+        this.remediation = options.remediation;
+        this.details = options.details;
+        this.causeCode = options.causeCode;
+    }
+}
+export { exitCodeForErrorCode };
+//# sourceMappingURL=escli-error.js.map

package/dist/lib/global-flags.js

@@ -0,0 +1,29 @@
+import { Flags } from '@oclif/core';
+export const globalFlags = {
+    quiet: Flags.boolean({ description: 'Suppress diagnostic output.', default: false }),
+    'api-key': Flags.string({ description: 'API key override.', helpGroup: 'GLOBAL' }),
+    'base-url': Flags.string({ description: 'Base URL override.', helpGroup: 'GLOBAL' }),
+    timeout: Flags.integer({ description: 'Request timeout in seconds.', default: 300, helpGroup: 'GLOBAL' }),
+    describe: Flags.boolean({ description: 'Emit compact machine-readable command description.', helpGroup: 'GLOBAL' }),
+    schema: Flags.boolean({ description: 'Emit full machine-readable command schema.', helpGroup: 'GLOBAL', allowNo: false }),
+    version: Flags.boolean({ char: 'v', description: 'Emit version envelope.', helpGroup: 'GLOBAL' }),
+};
+export const GLOBAL_FLAG_NAMES = ['json', ...Object.keys(globalFlags)];
+export const GLOBAL_VALUE_FLAG_NAMES = ['api-key', 'base-url', 'timeout'];
+export const GLOBAL_SHORT_FLAGS = new Map([['-v', 'version'], ['-h', 'help']]);
+const RUNNER_ONLY_GLOBAL_FLAG_NAMES = ['help'];
+export function isGlobalFlagToken(token) {
+    if (GLOBAL_SHORT_FLAGS.has(token))
+        return true;
+    if (!token.startsWith('--'))
+        return false;
+    const name = token.slice(2).split('=', 1)[0];
+    return GLOBAL_FLAG_NAMES.includes(name) || RUNNER_ONLY_GLOBAL_FLAG_NAMES.includes(name);
+}
+export function globalFlagTakesValue(token) {
+    if (!token.startsWith('--'))
+        return false;
+    const name = token.slice(2).split('=', 1)[0];
+    return GLOBAL_VALUE_FLAG_NAMES.includes(name);
+}
+//# sourceMappingURL=global-flags.js.map

package/dist/lib/globals.js

@@ -0,0 +1,2 @@
+export { GLOBAL_FLAG_NAMES, GLOBAL_SHORT_FLAGS, GLOBAL_VALUE_FLAG_NAMES, globalFlags, globalFlagTakesValue, isGlobalFlagToken } from './global-flags.js';
+//# sourceMappingURL=globals.js.map

package/dist/lib/manifest.js

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+import { EnvelopeSchema } from '@eightstate/contracts/envelope';
+import { ManifestSchema } from '@eightstate/contracts/manifest';
+import { commandRegistry } from './registry.js';
+function jsonSchema(schema) {
+    return z.toJSONSchema(schema);
+}
+export function buildManifest(compact = false, scope) {
+    const commands = {};
+    for (const command of commandRegistry) {
+        if (!isInScope(command.id, scope))
+            continue;
+        commands[command.id] = {
+            id: command.id,
+            aliases: [...command.aliases],
+            examples: [...command.examples],
+            flags: namedEntries(command.flags, normalizeFlag),
+            args: namedEntries(command.args, normalizeArg),
+            summary: command.summary,
+            description: command.description,
+            errors: [...command.errors],
+            ...(compact ? {} : {
+                input_schema: command.inputSchema ? jsonSchema(command.inputSchema) : undefined,
+                output_schema: jsonSchema(EnvelopeSchema(command.dataSchema)),
+            }),
+        };
+    }
+    return ManifestSchema.parse({ version: '0.5.0', commands });
+}
+function isInScope(commandId, scope) {
+    if (!scope)
+        return true;
+    return commandId === scope || commandId.startsWith(`${scope} `);
+}
+function namedEntries(entries, normalize) {
+    return Object.fromEntries(Object.entries(entries).map(([name, value]) => {
+        if (value && typeof value === 'object' && !Array.isArray(value))
+            return [name, normalize(name, value)];
+        return [name, { value, name }];
+    }));
+}
+function normalizeFlag(name, value) {
+    const normalized = { ...value, name };
+    normalized.type = normalized.type === 'option' ? inferOptionType(name, normalized) : normalized.type;
+    for (const key of ['input', 'allowNo'])
+        delete normalized[key];
+    if (normalized.multiple === false)
+        delete normalized.multiple;
+    return normalized;
+}
+function normalizeArg(name, value) {
+    const normalized = { ...value, name };
+    delete normalized.type;
+    delete normalized.input;
+    if (normalized.multiple === false)
+        delete normalized.multiple;
+    return normalized;
+}
+function inferOptionType(name, value) {
+    if (integerFlags.has(name) || Number.isInteger(value.default))
+        return 'integer';
+    if (Array.isArray(value.options) && value.options.every((option) => typeof option === 'number'))
+        return 'integer';
+    return 'string';
+}
+const integerFlags = new Set(['compression', 'speakers-expected', 'limit', 'tokens', 'page', 'max-results', 'days', 'timeout']);
+//# sourceMappingURL=manifest.js.map

package/dist/lib/oclif-manifest-check.js

@@ -0,0 +1,11 @@
+import { readFileSync } from 'node:fs';
+import { commandIds } from './registry.js';
+export function assertOclifManifestMatchesRegistry(path = 'oclif.manifest.json') {
+    const raw = JSON.parse(readFileSync(path, 'utf8'));
+    const manifestIds = Object.keys(raw.commands ?? {}).map((id) => id.replaceAll(':', ' ')).sort();
+    const registryIds = [...commandIds].sort();
+    if (JSON.stringify(manifestIds) !== JSON.stringify(registryIds)) {
+        throw new Error(`oclif manifest commands ${JSON.stringify(manifestIds)} do not match registry commands ${JSON.stringify(registryIds)}`);
+    }
+}
+//# sourceMappingURL=oclif-manifest-check.js.map

package/dist/lib/registry.js

@@ -0,0 +1,228 @@
+import { z } from 'zod';
+import ImageTopic from '../commands/image/index.js';
+import AudioTopic from '../commands/audio/index.js';
+import AuthTopic from '../commands/auth/index.js';
+import DocsTopic from '../commands/docs/index.js';
+import ImageGenerate, { ImageDataSchema } from '../commands/image/generate.js';
+import ImageEdit from '../commands/image/edit.js';
+import AudioGet, { AudioGetDataSchema } from '../commands/audio/get.js';
+import AudioList, { AudioListDataSchema } from '../commands/audio/list.js';
+import AudioStatus, { AudioStatusDataSchema } from '../commands/audio/status.js';
+import AudioTranscribe, { AudioTranscribeDataSchema } from '../commands/audio/transcribe.js';
+import AuthLogin, { AuthLoginDataSchema } from '../commands/auth/login.js';
+import AuthLogout, { AuthLogoutDataSchema } from '../commands/auth/logout.js';
+import AuthProfiles, { AuthProfilesDataSchema } from '../commands/auth/profiles.js';
+import AuthStatus, { AuthStatusDataSchema } from '../commands/auth/status.js';
+import AuthSwitch, { AuthSwitchDataSchema } from '../commands/auth/switch.js';
+import DocsFetch, { DocsContentDataSchema } from '../commands/docs/fetch.js';
+import DocsGet from '../commands/docs/get.js';
+import DocsSearch, { DocsSearchDataSchema } from '../commands/docs/search.js';
+import Fetch, { FetchDataSchema } from '../commands/fetch.js';
+import Models, { ModelsDataSchema } from '../commands/models.js';
+import Search, { SearchDataSchema } from '../commands/search.js';
+import Research, { ResearchDataSchema } from '../commands/research.js';
+import Social, { SocialDataSchema } from '../commands/social.js';
+import Usage, { UsageDataSchema } from '../commands/usage.js';
+import Version, { VersionDataSchema } from '../commands/version.js';
+import { registerCommandMetadata } from './command-metadata.js';
+import { renderAuthLogin, renderAuthLogout, renderAuthProfiles, renderAuthStatus, renderAuthSwitch, renderDocsContent, renderDocsSearch, renderFetch, renderModelList, renderResearch, renderSearch, renderSocial, renderUsage, renderVersion, } from '../io/io.js';
+const commandClasses = [
+    { id: 'image', command: ImageTopic },
+    { id: 'image generate', command: ImageGenerate },
+    { id: 'image edit', command: ImageEdit },
+    { id: 'audio', command: AudioTopic },
+    { id: 'audio transcribe', command: AudioTranscribe },
+    { id: 'audio status', command: AudioStatus },
+    { id: 'audio get', command: AudioGet },
+    { id: 'audio list', command: AudioList },
+    { id: 'auth', command: AuthTopic },
+    { id: 'auth login', command: AuthLogin },
+    { id: 'auth logout', command: AuthLogout },
+    { id: 'auth status', command: AuthStatus },
+    { id: 'auth profiles', command: AuthProfiles },
+    { id: 'auth switch', command: AuthSwitch },
+    { id: 'docs', command: DocsTopic },
+    { id: 'docs search', command: DocsSearch },
+    { id: 'docs get', command: DocsGet },
+    { id: 'docs fetch', command: DocsFetch },
+    { id: 'fetch', command: Fetch },
+    { id: 'models', command: Models },
+    { id: 'search', command: Search },
+    { id: 'research', command: Research },
+    { id: 'social', command: Social },
+    { id: 'usage', command: Usage },
+    { id: 'version', command: Version },
+];
+const aliasOverrides = new Map([
+    ['image', ['img', 'i']],
+    ['image generate', ['image gen', 'image g', 'img generate', 'img gen', 'img g', 'i generate', 'i gen', 'i g']],
+    ['image edit', ['image e', 'img edit', 'img e', 'i edit', 'i e']],
+    ['audio', ['au']],
+    ['audio transcribe', ['audio t', 'au transcribe', 'au t']],
+    ['audio status', ['audio s', 'au status', 'au s']],
+    ['audio get', ['audio g', 'au get', 'au g']],
+    ['audio list', ['audio ls', 'au list', 'au ls']],
+    ['auth', ['a']],
+    ['auth login', ['auth l', 'a login', 'a l']],
+    ['auth logout', ['auth out', 'a logout', 'a out']],
+    ['auth status', ['auth s', 'auth whoami', 'a status', 'a s', 'a whoami']],
+    ['auth profiles', ['auth ls', 'auth list', 'a profiles', 'a ls', 'a list']],
+    ['auth switch', ['auth use', 'a switch', 'a use']],
+    ['docs', ['d']],
+    ['docs search', ['docs s', 'd search', 'd s']],
+    ['docs get', ['docs g', 'd get', 'd g']],
+    ['docs fetch', ['docs f', 'd fetch', 'd f']],
+    ['fetch', ['f']],
+    ['models', ['m']],
+    ['search', ['s']],
+    ['research', ['r']],
+    ['social', []],
+    ['usage', ['u']],
+    ['version', []],
+]);
+const metadataEntries = [
+    ['image', { inputSchema: z.object({}), dataSchema: z.object({}) }],
+    ['image generate', { inputSchema: z.object({
+                prompt: z.array(z.string()).min(1),
+                size: z.string().optional(),
+                quality: z.enum(['low', 'medium', 'high']).optional(),
+                format: z.enum(['png', 'jpeg', 'jpg', 'webp']).optional(),
+                model: z.string().optional(),
+                output: z.string().optional(),
+                'out-dir': z.string().optional(),
+                open: z.boolean().optional(),
+                compression: z.number().int().optional(),
+                moderation: z.enum(['auto', 'low']).optional(),
+                background: z.enum(['auto', 'transparent']).optional(),
+            }), dataSchema: ImageDataSchema }],
+    ['image edit', { inputSchema: z.object({
+                prompt: z.array(z.string()).min(1),
+                input: z.string(),
+                size: z.string().optional(),
+                quality: z.enum(['low', 'medium', 'high']).optional(),
+                format: z.enum(['png', 'jpeg', 'jpg', 'webp']).optional(),
+                model: z.string().optional(),
+                output: z.string().optional(),
+                'out-dir': z.string().optional(),
+                open: z.boolean().optional(),
+                compression: z.number().int().optional(),
+                moderation: z.enum(['auto', 'low']).optional(),
+                fidelity: z.enum(['low', 'high']).optional(),
+            }), dataSchema: ImageDataSchema }],
+    ['audio', { inputSchema: z.object({}), dataSchema: z.object({}) }],
+    ['audio transcribe', { inputSchema: z.object({
+                source: z.string(),
+                output: z.string().optional(),
+                format: z.enum(['text', 'json', 'srt', 'vtt']).optional(),
+                speakers: z.boolean().optional(),
+                'speakers-expected': z.number().int().optional(),
+                'speaker-names': z.string().optional(),
+                sentiment: z.boolean().optional(),
+                chapters: z.boolean().optional(),
+                entities: z.boolean().optional(),
+                summarize: z.boolean().optional(),
+                highlights: z.boolean().optional(),
+                topics: z.boolean().optional(),
+                'content-safety': z.boolean().optional(),
+                language: z.string().optional(),
+                'dual-channel': z.boolean().optional(),
+                multichannel: z.boolean().optional(),
+                'word-boost': z.string().optional(),
+                disfluencies: z.boolean().optional(),
+                'filter-profanity': z.boolean().optional(),
+                'redact-pii': z.boolean().optional(),
+            }), dataSchema: AudioTranscribeDataSchema }],
+    ['audio status', { inputSchema: z.object({ transcript_id: z.string() }), dataSchema: AudioStatusDataSchema }],
+    ['audio get', { inputSchema: z.object({ transcript_id: z.string(), format: z.enum(['text', 'json', 'srt', 'vtt']).optional(), output: z.string().optional() }), dataSchema: AudioGetDataSchema }],
+    ['audio list', { inputSchema: z.object({}), dataSchema: AudioListDataSchema }],
+    ['auth', { inputSchema: z.object({}), dataSchema: z.object({}) }],
+    ['auth login', { inputSchema: z.object({
+                key: z.string().optional(),
+                endpoint: z.string().optional(),
+                profile: z.string().optional(),
+                label: z.string().optional(),
+            }), dataSchema: AuthLoginDataSchema, render: renderAuthLogin }],
+    ['auth logout', { inputSchema: z.object({ profile: z.string().optional(), all: z.boolean().optional() }), dataSchema: AuthLogoutDataSchema, render: renderAuthLogout }],
+    ['auth status', { inputSchema: z.object({}), dataSchema: AuthStatusDataSchema, render: renderAuthStatus }],
+    ['auth profiles', { inputSchema: z.object({}), dataSchema: AuthProfilesDataSchema, render: renderAuthProfiles }],
+    ['auth switch', { inputSchema: z.object({ profile: z.string() }), dataSchema: AuthSwitchDataSchema, render: renderAuthSwitch }],
+    ['docs', { inputSchema: z.object({}), dataSchema: z.object({}) }],
+    ['docs search', { inputSchema: z.object({ library: z.string(), query: z.string().optional(), limit: z.number().int().optional(), refresh: z.boolean().optional() }), dataSchema: DocsSearchDataSchema, render: renderDocsSearch }],
+    ['docs get', { inputSchema: z.object({ library: z.string(), query: z.string(), tokens: z.number().int().optional(), page: z.number().int().optional(), topic: z.string().optional(), refresh: z.boolean().optional() }), dataSchema: DocsContentDataSchema, render: renderDocsContent }],
+    ['docs fetch', { inputSchema: z.object({ 'library-id': z.string(), query: z.string(), tokens: z.number().int().optional(), page: z.number().int().optional(), topic: z.string().optional(), refresh: z.boolean().optional() }), dataSchema: DocsContentDataSchema, render: renderDocsContent }],
+    ['fetch', { inputSchema: z.object({ urls: z.array(z.string()).min(1), objective: z.string().optional(), full: z.boolean().optional() }), dataSchema: FetchDataSchema, render: renderFetch }],
+    ['models', { inputSchema: z.object({}), dataSchema: ModelsDataSchema, render: renderModelList }],
+    ['search', { inputSchema: z.object({ objective: z.array(z.string()).min(1), queries: z.array(z.string()).optional() }), dataSchema: SearchDataSchema, render: renderSearch }],
+    ['research', { inputSchema: z.object({
+                query: z.array(z.string()).optional(),
+                processors: z.boolean().optional(),
+                status: z.string().optional(),
+                result: z.string().optional(),
+                output: z.string().optional(),
+                processor: z.string().optional(),
+                text: z.boolean().optional(),
+                schema: z.string().optional(),
+                'output-schema': z.string().optional(),
+                'input-json': z.string().optional(),
+                'input-file': z.string().optional(),
+                'include-domains': z.string().optional(),
+                'exclude-domains': z.string().optional(),
+                'after-date': z.string().optional(),
+                location: z.string().optional(),
+                metadata: z.string().optional(),
+                'follow-up': z.string().optional(),
+                'no-basis': z.boolean().optional(),
+            }), dataSchema: ResearchDataSchema, render: renderResearch }],
+    ['social', { inputSchema: z.object({
+                query: z.array(z.string()).min(1),
+                platform: z.string().optional(),
+                time: z.enum(['day', 'week', 'month', 'year']).optional(),
+                'max-results': z.number().int().optional(),
+                depth: z.enum(['basic', 'advanced', 'fast', 'ultra-fast']).optional(),
+                answer: z.boolean().optional(),
+                raw: z.boolean().optional(),
+                images: z.boolean().optional(),
+                country: z.string().optional(),
+            }), dataSchema: SocialDataSchema, render: renderSocial }],
+    ['usage', { inputSchema: z.object({
+                days: z.number().int().optional(),
+                service: z.string().optional(),
+                daily: z.boolean().optional(),
+                pricing: z.boolean().optional(),
+            }), dataSchema: UsageDataSchema, render: renderUsage }],
+    ['version', { inputSchema: z.object({}), dataSchema: VersionDataSchema, render: renderVersion }],
+];
+const metadata = new Map(metadataEntries);
+export const commandRegistry = commandClasses.map(({ id, command }) => buildRegistration(id, command));
+for (const registration of commandRegistry) {
+    registerCommandMetadata({
+        id: registration.id,
+        dataSchema: registration.dataSchema,
+        inputSchema: registration.inputSchema,
+        errors: registration.errors,
+        render: registration.render,
+    });
+}
+function buildRegistration(id, command) {
+    const commandMetadata = metadata.get(id) ?? { dataSchema: z.object({}) };
+    return {
+        id,
+        command,
+        aliases: aliasOverrides.get(id) ?? command.aliases ?? [],
+        examples: normalizeExamples(command.examples ?? []),
+        flags: command.flags ?? {},
+        args: command.args ?? {},
+        summary: command.summary ?? '',
+        description: command.description,
+        dataSchema: commandMetadata.dataSchema,
+        inputSchema: commandMetadata.inputSchema,
+        errors: command.errors ?? [],
+        render: commandMetadata.render,
+    };
+}
+function normalizeExamples(examples) {
+    return examples.map((example) => example.replaceAll('<%= config.bin %>', 'escli'));
+}
+export const commandsById = new Map(commandRegistry.flatMap((command) => [[command.id, command], ...command.aliases.map((alias) => [alias, command])]));
+export const commandIds = commandRegistry.map((command) => command.id);
+//# sourceMappingURL=registry.js.map