@eightstate/escli 0.5.0

package/dist/commands/auth/login.js

@@ -0,0 +1,38 @@
+import { Flags } from '@oclif/core';
+import { z } from 'zod';
+import { ErrorCode } from '@eightstate/contracts/errors';
+import { ExitCodes } from '@eightstate/contracts/exit-codes';
+import { BaseCommand } from '../../base-command.js';
+import { EscliError } from '../../lib/escli-error.js';
+import { authLogin } from '../../services/auth.js';
+export const AuthLoginDataSchema = z.object({
+    profile: z.string(),
+    auth_type: z.enum(['api_key', 'gate']),
+    endpoint: z.string().optional(),
+    gate: z.string().optional(),
+    key: z.string().optional(),
+    models: z.string().optional(),
+    config_path: z.string().optional(),
+});
+export default class AuthLogin extends BaseCommand {
+    static errors = [ErrorCode.AuthInvalid, ErrorCode.AuthForbidden, ErrorCode.AuthLoginFailed, ErrorCode.AuthSessionExpired, ErrorCode.AuthTimeout, ErrorCode.GateUnavailable, ErrorCode.GateInvalidResponse, ErrorCode.NetworkError, ErrorCode.NetworkTimeout];
+    static summary = 'Authenticate via browser or API key';
+    static description = 'Authenticate via browser device flow or store an API key profile.';
+    static examples = ['<%= config.bin %> auth login', '<%= config.bin %> auth login --key sk-xxx', 'echo sk-xxx | <%= config.bin %> auth login'];
+    static aliases = ['auth l'];
+    static enableJsonFlag = true;
+    static strict = true;
+    static flags = {
+        key: Flags.string({ char: 'k', description: 'API key for non-interactive login.' }),
+        endpoint: Flags.string({ description: 'OpenAI-compatible endpoint for API-key validation.' }),
+        profile: Flags.string({ char: 'p', description: 'Profile name.', default: 'default' }),
+        label: Flags.string({ description: 'Human label for the profile.' }),
+    };
+    async execute() {
+        const flags = await this.parseFlags(AuthLogin);
+        if (flags.key === '')
+            throw new EscliError('Missing required flag key', { code: ErrorCode.UsageRequired, exitCode: ExitCodes.Usage });
+        return authLogin({ key: flags.key, endpoint: flags.endpoint, profile: flags.profile, label: flags.label, timeoutSeconds: flags.timeout });
+    }
+}
+//# sourceMappingURL=login.js.map

package/dist/commands/auth/logout.js

@@ -0,0 +1,27 @@
+import { Flags } from '@oclif/core';
+import { z } from 'zod';
+import { BaseCommand } from '../../base-command.js';
+import { authLogout } from '../../services/auth.js';
+export const AuthLogoutDataSchema = z.object({
+    profile: z.string().optional(),
+    deleted: z.boolean().optional(),
+    message: z.string().optional(),
+});
+export default class AuthLogout extends BaseCommand {
+    static errors = [];
+    static summary = 'Remove stored credentials';
+    static description = 'Remove one stored auth profile or all profiles.';
+    static examples = ['<%= config.bin %> auth logout', '<%= config.bin %> auth logout --profile work', '<%= config.bin %> auth logout --all'];
+    static aliases = [];
+    static enableJsonFlag = true;
+    static strict = true;
+    static flags = {
+        profile: Flags.string({ char: 'p', description: 'Profile name to remove.' }),
+        all: Flags.boolean({ description: 'Remove all profiles.' }),
+    };
+    async execute() {
+        const flags = await this.parseFlags(AuthLogout);
+        return authLogout({ profile: flags.profile, all: flags.all });
+    }
+}
+//# sourceMappingURL=logout.js.map

package/dist/commands/auth/profiles.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { BaseCommand } from '../../base-command.js';
+import { authProfiles } from '../../services/auth.js';
+import { ErrorCode } from '@eightstate/contracts/errors';
+export const AuthProfilesDataSchema = z.object({
+    profiles: z.array(z.object({
+        name: z.string(),
+        label: z.string(),
+        key: z.string(),
+        auth_type: z.enum(['api_key', 'gate']),
+        endpoint: z.string(),
+        active: z.boolean(),
+        created: z.string(),
+    })),
+    count: z.number().int().nonnegative(),
+});
+export default class AuthProfiles extends BaseCommand {
+    static errors = [ErrorCode.Internal];
+    static summary = 'List all stored profiles';
+    static description = 'List all stored auth profiles.';
+    static examples = ['<%= config.bin %> auth profiles', '<%= config.bin %> auth ls'];
+    static aliases = ['auth ls', 'auth list'];
+    static enableJsonFlag = true;
+    static strict = true;
+    static flags = {};
+    async execute() {
+        await this.parseFlags(AuthProfiles);
+        return authProfiles();
+    }
+}
+//# sourceMappingURL=profiles.js.map

package/dist/commands/auth/status.js

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { BaseCommand } from '../../base-command.js';
+import { authStatus } from '../../services/auth.js';
+import { ErrorCode } from '@eightstate/contracts/errors';
+export const AuthStatusDataSchema = z.object({
+    authenticated: z.literal(true),
+    profile: z.string(),
+    auth_type: z.enum(['api_key', 'gate']),
+    endpoint: z.string(),
+    key: z.string().optional(),
+    config_path: z.string().optional(),
+});
+export default class AuthStatus extends BaseCommand {
+    static errors = [ErrorCode.AuthRequired];
+    static summary = 'Show current profile and auth state';
+    static description = 'Show the active auth profile and credential type.';
+    static examples = ['<%= config.bin %> auth status', '<%= config.bin %> auth whoami'];
+    static aliases = ['auth s', 'auth whoami'];
+    static enableJsonFlag = true;
+    static strict = true;
+    static flags = {};
+    async execute() {
+        await this.parseFlags(AuthStatus);
+        return authStatus();
+    }
+}
+//# sourceMappingURL=status.js.map

package/dist/commands/auth/switch.js

@@ -0,0 +1,24 @@
+import { Args } from '@oclif/core';
+import { z } from 'zod';
+import { BaseCommand } from '../../base-command.js';
+import { authSwitch } from '../../services/auth.js';
+import { ErrorCode } from '@eightstate/contracts/errors';
+export const AuthSwitchDataSchema = z.object({ active_profile: z.string() });
+export default class AuthSwitch extends BaseCommand {
+    static errors = [ErrorCode.AuthProfileNotFound, ErrorCode.UsageRequired];
+    static summary = 'Switch the active profile';
+    static description = 'Switch the active auth profile.';
+    static examples = ['<%= config.bin %> auth switch work', '<%= config.bin %> auth use work'];
+    static aliases = ['auth use'];
+    static enableJsonFlag = true;
+    static strict = true;
+    static flags = {};
+    static args = {
+        profile: Args.string({ description: 'Profile name.', required: true }),
+    };
+    async execute() {
+        const { args } = await this.parse(AuthSwitch);
+        return authSwitch(args.profile);
+    }
+}
+//# sourceMappingURL=switch.js.map

package/dist/commands/docs/fetch.js

@@ -0,0 +1,37 @@
+import { Args, Flags } from '@oclif/core';
+import { BaseCommand } from '../../base-command.js';
+import { fetchDocs } from '../../services/docs.js';
+import { DocsContentDataSchema } from './get.js';
+import { ErrorCode } from '@eightstate/contracts/errors';
+export default class DocsFetch extends BaseCommand {
+    static errors = [ErrorCode.ApiUnauthorized, ErrorCode.ApiForbidden, ErrorCode.ApiRateLimited, ErrorCode.GateInvalidResponse, ErrorCode.NetworkError, ErrorCode.NetworkTimeout, ErrorCode.ServiceUnavailable, ErrorCode.DocsLibraryNotFound, ErrorCode.DocsFetchFailed];
+    static summary = 'Fetch docs by exact library ID';
+    static description = 'Fetch Context7 documentation by exact library ID.';
+    static examples = ['<%= config.bin %> docs fetch /facebook/react hooks', '<%= config.bin %> docs fetch /vercel/next.js actions --tokens 5000', '<%= config.bin %> d f /facebook/react hooks'];
+    static aliases = ['docs f', 'd fetch', 'd f'];
+    static flags = {
+        tokens: Flags.integer({ description: 'Max tokens to return.' }),
+        page: Flags.integer({ description: 'Page number (1-10).' }),
+        topic: Flags.string({ description: 'Focus on a topic.' }),
+        refresh: Flags.boolean({ description: 'Bypass cache.', default: false }),
+    };
+    static args = {
+        'library-id': Args.string({ description: 'Library ID (for example /facebook/react).', required: true }),
+        query: Args.string({ description: 'Documentation query.', required: true }),
+    };
+    static enableJsonFlag = true;
+    static strict = true;
+    async execute() {
+        const { args, flags } = await this.parse(DocsFetch);
+        return fetchDocs({
+            libraryId: args['library-id'],
+            query: args.query,
+            tokens: flags.tokens,
+            page: flags.page,
+            topic: flags.topic,
+            refresh: flags.refresh,
+        });
+    }
+}
+export { DocsContentDataSchema };
+//# sourceMappingURL=fetch.js.map

package/dist/commands/docs/get.js

@@ -0,0 +1,47 @@
+import { Args, Flags } from '@oclif/core';
+import { z } from 'zod';
+import { BaseCommand } from '../../base-command.js';
+import { writeStderr } from '../../io/io.js';
+import { getDocs } from '../../services/docs.js';
+import { ErrorCode } from '@eightstate/contracts/errors';
+export const DocsContentDataSchema = z.object({
+    operation: z.enum(['get', 'fetch']).optional(),
+    cached: z.boolean(),
+    library_id: z.string(),
+    query: z.string(),
+    content: z.string(),
+});
+export default class DocsGet extends BaseCommand {
+    static errors = [ErrorCode.ApiUnauthorized, ErrorCode.ApiForbidden, ErrorCode.ApiRateLimited, ErrorCode.GateInvalidResponse, ErrorCode.NetworkError, ErrorCode.NetworkTimeout, ErrorCode.ServiceUnavailable, ErrorCode.DocsLibraryNotFound, ErrorCode.DocsNoResults, ErrorCode.DocsFetchFailed];
+    static summary = 'Resolve a library and fetch docs in one shot';
+    static description = 'Resolve a library name to a Context7 library ID, then fetch documentation.';
+    static examples = ['<%= config.bin %> docs get react hooks', '<%= config.bin %> docs get next.js "app router" --tokens 5000', '<%= config.bin %> d g react "useEffect cleanup"'];
+    static aliases = ['docs g', 'd get', 'd g'];
+    static flags = {
+        tokens: Flags.integer({ description: 'Max tokens to return.' }),
+        page: Flags.integer({ description: 'Page number (1-10).' }),
+        topic: Flags.string({ description: 'Focus on a topic.' }),
+        refresh: Flags.boolean({ description: 'Bypass cache.', default: false }),
+    };
+    static args = {
+        library: Args.string({ description: 'Library name.', required: true }),
+        query: Args.string({ description: 'Documentation query.', required: true }),
+    };
+    static enableJsonFlag = true;
+    static strict = true;
+    async execute() {
+        const { args, flags } = await this.parse(DocsGet);
+        const data = await getDocs({
+            libraryName: args.library,
+            query: args.query,
+            tokens: flags.tokens,
+            page: flags.page,
+            topic: flags.topic,
+            refresh: flags.refresh,
+        });
+        if (!flags.quiet && !flags.json)
+            await writeStderr(`  → resolved: ${data.library_id}\n`);
+        return data;
+    }
+}
+//# sourceMappingURL=get.js.map

package/dist/commands/docs/index.js

@@ -0,0 +1,18 @@
+import { BaseCommand } from '../../base-command.js';
+import { buildUsageError } from '../../lib/envelope.js';
+import { ErrorCode } from '@eightstate/contracts/errors';
+export default class DocsTopic extends BaseCommand {
+    static errors = [ErrorCode.UsageInvalid];
+    static summary = 'Search and fetch library documentation';
+    static description = 'Use docs search, docs get, or docs fetch.';
+    static examples = ['<%= config.bin %> docs search react', '<%= config.bin %> docs get react hooks', '<%= config.bin %> docs fetch /facebook/react hooks'];
+    static aliases = ['d'];
+    static flags = {};
+    static args = {};
+    static enableJsonFlag = true;
+    static strict = true;
+    async execute() {
+        throw buildUsageError('usage: escli docs <search|get|fetch>');
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/docs/search.js

@@ -0,0 +1,55 @@
+import { Args, Flags } from '@oclif/core';
+import { z } from 'zod';
+import { BaseCommand } from '../../base-command.js';
+import { renderDocsSearch, renderDocsSearchTsv, writeStdout, writeStderr } from '../../io/io.js';
+import { searchDocs } from '../../services/docs.js';
+import { ErrorCode } from '@eightstate/contracts/errors';
+export const DocsSearchResultSchema = z.object({
+    id: z.string(),
+    title: z.string(),
+    state: z.string().optional(),
+    stars: z.number().optional(),
+    description: z.string().optional(),
+});
+export const DocsSearchDataSchema = z.object({
+    operation: z.literal('search').optional(),
+    cached: z.boolean(),
+    results: z.array(DocsSearchResultSchema),
+    count: z.number().int().nonnegative(),
+});
+export default class DocsSearch extends BaseCommand {
+    static errors = [ErrorCode.ApiUnauthorized, ErrorCode.ApiForbidden, ErrorCode.ApiRateLimited, ErrorCode.GateInvalidResponse, ErrorCode.NetworkError, ErrorCode.NetworkTimeout, ErrorCode.ServiceUnavailable, ErrorCode.DocsLibraryNotFound, ErrorCode.DocsFetchFailed];
+    static summary = 'Search for libraries by name';
+    static description = 'Search Context7 for library documentation IDs.';
+    static examples = ['<%= config.bin %> docs search react', '<%= config.bin %> docs search react hooks --limit 2', '<%= config.bin %> d s next.js'];
+    static aliases = ['docs s', 'd search', 'd s'];
+    static flags = {
+        limit: Flags.integer({ description: 'Max results.', default: 10 }),
+        refresh: Flags.boolean({ description: 'Bypass cache.', default: false }),
+    };
+    static args = {
+        library: Args.string({ description: 'Library name.', required: true }),
+        query: Args.string({ description: 'Optional search query.', required: false }),
+    };
+    static enableJsonFlag = true;
+    static strict = true;
+    async execute() {
+        const { args, flags } = await this.parse(DocsSearch);
+        const data = await searchDocs({
+            libraryName: args.library,
+            query: args.query,
+            limit: flags.limit,
+            refresh: flags.refresh,
+        });
+        if (flags.quiet && !flags.json) {
+            await writeStdout(renderDocsSearchTsv(data));
+            this.humanOutputHandled = true;
+        }
+        else if (!flags.json) {
+            await writeStderr(renderDocsSearch(data));
+            this.humanOutputHandled = true;
+        }
+        return data;
+    }
+}
+//# sourceMappingURL=search.js.map

package/dist/commands/fetch.js

@@ -0,0 +1,55 @@
+import { Args, Flags } from '@oclif/core';
+import { z } from 'zod';
+import { BaseCommand } from '../base-command.js';
+import { writeStderr } from '../io/io.js';
+import { fetchUrls } from '../services/fetch.js';
+import { ErrorCode } from '@eightstate/contracts/errors';
+export const FetchResultSchema = z.object({
+    title: z.string().nullable().optional(),
+    url: z.string(),
+    excerpts: z.array(z.string()).default([]),
+    full_content: z.string().nullable().optional(),
+    publish_date: z.string().nullable().optional(),
+}).passthrough();
+export const FetchDataSchema = z.object({
+    elapsed_seconds: z.number().nonnegative().optional(),
+    results: z.array(FetchResultSchema),
+    count: z.number().int().nonnegative(),
+});
+export default class Fetch extends BaseCommand {
+    static errors = [ErrorCode.UsageRequired, ErrorCode.ApiUnauthorized, ErrorCode.ApiForbidden, ErrorCode.ApiRateLimited, ErrorCode.FileNotFound, ErrorCode.GateInvalidResponse, ErrorCode.JsonInvalid, ErrorCode.NetworkError, ErrorCode.NetworkTimeout, ErrorCode.ServiceUnavailable, ErrorCode.FetchFailed];
+    static summary = 'Extract clean content from URLs';
+    static description = 'Extract clean content from URLs via Parallel Extract.';
+    static examples = [
+        '<%= config.bin %> fetch https://docs.parallel.ai/search/search-quickstart',
+        '<%= config.bin %> fetch https://example.com --objective "pricing information"',
+        '<%= config.bin %> fetch https://example.com --full',
+        '<%= config.bin %> --json fetch https://example.com https://other.com',
+    ];
+    static aliases = ['f'];
+    static flags = {
+        objective: Flags.string({ description: 'Focus on this topic.' }),
+        full: Flags.boolean({ description: 'Return full content instead of excerpts.', default: false }),
+    };
+    static args = {
+        urls: Args.string({ description: 'URLs to extract.', required: true, multiple: true }),
+    };
+    static enableJsonFlag = true;
+    static strict = true;
+    async execute() {
+        const { args, flags } = await this.parse(Fetch);
+        const urls = args.urls;
+        if (!flags.quiet && !flags.json)
+            await writeStderr(`  ▸ fetching ${urls.length} URL(s)...\n`);
+        const data = await fetchUrls({
+            urls,
+            objective: flags.objective,
+            full: flags.full,
+            timeoutSeconds: flags.timeout,
+        });
+        if (!flags.quiet && !flags.json)
+            await writeStderr(`  ${data.count} page(s) · ${data.elapsed_seconds}s\n`);
+        return data;
+    }
+}
+//# sourceMappingURL=fetch.js.map

package/dist/commands/image/edit.js

@@ -0,0 +1,59 @@
+import { Args, Flags } from '@oclif/core';
+import { BaseCommand } from '../../base-command.js';
+import { writeStdout } from '../../io/io.js';
+import { editImage } from '../../services/image.js';
+import { ImageDataSchema } from './generate.js';
+import { ErrorCode } from '@eightstate/contracts/errors';
+export const ImageEditDataSchema = ImageDataSchema;
+export default class ImageEdit extends BaseCommand {
+    static errors = [ErrorCode.UsageRequired, ErrorCode.UsageInvalid, ErrorCode.UsageUnknownFlag, ErrorCode.ValidationFailed, ErrorCode.AuthRequired, ErrorCode.GateCredentialUnavailable, ErrorCode.ApiUnauthorized, ErrorCode.ApiForbidden, ErrorCode.ApiRateLimited, ErrorCode.ApiError, ErrorCode.NetworkError, ErrorCode.NetworkTimeout, ErrorCode.ServiceUnavailable, ErrorCode.GateInvalidResponse, ErrorCode.FileNotFound, ErrorCode.FileReadFailed, ErrorCode.FileWriteFailed, ErrorCode.ImagePromptRequired, ErrorCode.ImageSizeInvalid, ErrorCode.ImageEditFailed, ErrorCode.ImageOpenFailed];
+    static summary = 'Edit an existing image with a text prompt';
+    static description = 'Edit an existing image using a text instruction via the OpenAI-compatible image endpoint.';
+    static examples = ['<%= config.bin %> image edit "make it snow" -i summer.jpg', '<%= config.bin %> image edit "make it blue" -i input.png -o output.png', '<%= config.bin %> --json --quiet image edit "remove the background" -i product.png'];
+    static aliases = ['image e', 'img edit', 'img e', 'i edit', 'i e'];
+    static flags = {
+        input: Flags.string({ char: 'i', description: 'Input image path.', required: true }),
+        size: Flags.string({ char: 's', description: 'Size: sq|wide|tall or WxH.', default: process.env.ESCLI_IMAGE_SIZE ?? '1024x1024' }),
+        quality: Flags.string({ char: 'q', description: 'Quality.', options: ['low', 'medium', 'high'], default: process.env.ESCLI_IMAGE_QUALITY ?? 'high' }),
+        format: Flags.string({ char: 'f', description: 'Output format.', options: ['png', 'jpeg', 'jpg', 'webp'], default: process.env.ESCLI_IMAGE_FORMAT ?? 'png' }),
+        model: Flags.string({ char: 'm', description: 'Model.', default: process.env.ESCLI_IMAGE_MODEL ?? 'gpt-image-2' }),
+        output: Flags.string({ char: 'o', description: 'Output path.' }),
+        'out-dir': Flags.string({ char: 'd', description: 'Output directory.', default: process.env.ESCLI_OUT_DIR ?? '.' }),
+        open: Flags.boolean({ description: 'Open result after writing.', default: false }),
+        compression: Flags.integer({ description: 'JPEG/WebP compression 0-100.' }),
+        moderation: Flags.string({ description: 'Moderation.', options: ['auto', 'low'] }),
+        fidelity: Flags.string({ description: 'Fidelity to input.', options: ['low', 'high'] }),
+    };
+    static args = {
+        prompt: Args.string({ description: 'Edit instruction.', required: true, multiple: true }),
+    };
+    static enableJsonFlag = true;
+    static strict = true;
+    async execute() {
+        const { args, flags } = await this.parse(ImageEdit);
+        const options = {
+            prompt: args.prompt.join(' '),
+            input: flags.input,
+            size: flags.size,
+            quality: flags.quality,
+            format: flags.format,
+            model: flags.model,
+            output: flags.output,
+            outDir: flags['out-dir'],
+            compression: flags.compression,
+            moderation: flags.moderation,
+            fidelity: flags.fidelity,
+            apiKey: flags['api-key'],
+            baseUrl: flags['base-url'],
+            timeoutSeconds: flags.timeout,
+        };
+        const data = await editImage(options);
+        if (!flags.json) {
+            if (flags.quiet)
+                await writeStdout(`${data.path}\n`);
+            this.humanOutputHandled = true;
+        }
+        return data;
+    }
+}
+//# sourceMappingURL=edit.js.map

package/dist/commands/image/generate.js

@@ -0,0 +1,67 @@
+import { Args, Flags } from '@oclif/core';
+import { z } from 'zod';
+import { BaseCommand } from '../../base-command.js';
+import { writeStdout } from '../../io/io.js';
+import { generateImage } from '../../services/image.js';
+import { ErrorCode } from '@eightstate/contracts/errors';
+export const ImageDataSchema = z.object({
+    path: z.string(),
+    size_bytes: z.number().int().positive(),
+    elapsed_seconds: z.number().nonnegative(),
+    prompt: z.string(),
+    input: z.string().optional(),
+    model: z.string(),
+    image_size: z.string(),
+    quality: z.string(),
+    revised_prompt: z.string().optional(),
+});
+export default class ImageGenerate extends BaseCommand {
+    static errors = [ErrorCode.UsageRequired, ErrorCode.UsageInvalid, ErrorCode.UsageUnknownFlag, ErrorCode.ValidationFailed, ErrorCode.AuthRequired, ErrorCode.GateCredentialUnavailable, ErrorCode.ApiUnauthorized, ErrorCode.ApiForbidden, ErrorCode.ApiRateLimited, ErrorCode.ApiError, ErrorCode.NetworkError, ErrorCode.NetworkTimeout, ErrorCode.ServiceUnavailable, ErrorCode.GateInvalidResponse, ErrorCode.FileWriteFailed, ErrorCode.ImagePromptRequired, ErrorCode.ImageSizeInvalid, ErrorCode.ImageGenerationFailed, ErrorCode.ImageOpenFailed];
+    static summary = 'Generate an image from a text prompt';
+    static description = 'Generate an image from a text prompt via the OpenAI-compatible image endpoint.';
+    static examples = ['<%= config.bin %> image generate "a sunset over the ocean"', '<%= config.bin %> image generate "logo design" -s wide -q high -o logo.png', '<%= config.bin %> --json --quiet image generate "a logo" -o /tmp/logo.png'];
+    static aliases = ['image gen', 'image g', 'img generate', 'img gen', 'img g', 'i generate', 'i gen', 'i g'];
+    static flags = {
+        size: Flags.string({ char: 's', description: 'Size: sq|wide|tall or WxH.', default: process.env.ESCLI_IMAGE_SIZE ?? '1024x1024' }),
+        quality: Flags.string({ char: 'q', description: 'Quality.', options: ['low', 'medium', 'high'], default: process.env.ESCLI_IMAGE_QUALITY ?? 'high' }),
+        format: Flags.string({ char: 'f', description: 'Output format.', options: ['png', 'jpeg', 'jpg', 'webp'], default: process.env.ESCLI_IMAGE_FORMAT ?? 'png' }),
+        model: Flags.string({ char: 'm', description: 'Model.', default: process.env.ESCLI_IMAGE_MODEL ?? 'gpt-image-2' }),
+        output: Flags.string({ char: 'o', description: 'Output path.' }),
+        'out-dir': Flags.string({ char: 'd', description: 'Output directory.', default: process.env.ESCLI_OUT_DIR ?? '.' }),
+        open: Flags.boolean({ description: 'Open result after writing.', default: false }),
+        compression: Flags.integer({ description: 'JPEG/WebP compression 0-100.' }),
+        moderation: Flags.string({ description: 'Moderation.', options: ['auto', 'low'] }),
+        background: Flags.string({ description: 'Background.', options: ['auto', 'transparent'] }),
+    };
+    static args = {
+        prompt: Args.string({ description: 'Text prompt.', required: true, multiple: true }),
+    };
+    static enableJsonFlag = true;
+    static strict = true;
+    async execute() {
+        const { args, flags } = await this.parse(ImageGenerate);
+        const options = {
+            prompt: args.prompt.join(' '),
+            size: flags.size,
+            quality: flags.quality,
+            format: flags.format,
+            model: flags.model,
+            output: flags.output,
+            outDir: flags['out-dir'],
+            compression: flags.compression,
+            moderation: flags.moderation,
+            background: flags.background,
+            apiKey: flags['api-key'],
+            baseUrl: flags['base-url'],
+            timeoutSeconds: flags.timeout,
+        };
+        const data = await generateImage(options);
+        if (!flags.json) {
+            if (flags.quiet)
+                await writeStdout(`${data.path}\n`);
+            this.humanOutputHandled = true;
+        }
+        return data;
+    }
+}
+//# sourceMappingURL=generate.js.map

package/dist/commands/image/index.js

@@ -0,0 +1,18 @@
+import { BaseCommand } from '../../base-command.js';
+import { buildUsageError } from '../../lib/envelope.js';
+import { ErrorCode } from '@eightstate/contracts/errors';
+export default class ImageTopic extends BaseCommand {
+    static errors = [ErrorCode.UsageInvalid];
+    static summary = 'Generate or edit images from prompts';
+    static description = 'Use image generate or image edit.';
+    static examples = ['<%= config.bin %> image generate "a sunset"', '<%= config.bin %> image edit "make it blue" -i input.png'];
+    static aliases = ['img', 'i'];
+    static flags = {};
+    static args = {};
+    static enableJsonFlag = true;
+    static strict = true;
+    async execute() {
+        throw buildUsageError('usage: escli image <generate|edit>');
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/models.js

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { BaseCommand } from '../base-command.js';
+import { listModels } from '../services/models.js';
+import { ErrorCode } from '@eightstate/contracts/errors';
+export const ModelsDataSchema = z.object({
+    models: z.array(z.string()),
+    count: z.number().int().nonnegative(),
+});
+export default class Models extends BaseCommand {
+    static errors = [ErrorCode.AuthRequired, ErrorCode.ApiUnauthorized, ErrorCode.ApiForbidden, ErrorCode.ApiRateLimited, ErrorCode.ApiError, ErrorCode.NetworkError, ErrorCode.NetworkTimeout, ErrorCode.ServiceUnavailable, ErrorCode.ModelsListFailed];
+    static summary = 'List models available on the endpoint';
+    static description = 'List all models available on the API endpoint.';
+    static examples = ['<%= config.bin %> models', '<%= config.bin %> --json models'];
+    static aliases = ['m'];
+    static flags = {};
+    static enableJsonFlag = true;
+    static strict = true;
+    async execute() {
+        const flags = await this.parseFlags(Models);
+        return listModels({
+            apiKey: flags['api-key'],
+            baseUrl: flags['base-url'],
+            timeoutSeconds: flags.timeout,
+        });
+    }
+}
+//# sourceMappingURL=models.js.map

package/dist/commands/research.js

@@ -0,0 +1,92 @@
+import { Args, Flags } from '@oclif/core';
+import { z } from 'zod';
+import { ErrorCode } from '@eightstate/contracts/errors';
+import { ExitCodes } from '@eightstate/contracts/exit-codes';
+import { BaseCommand } from '../base-command.js';
+import { EscliError } from '../lib/escli-error.js';
+import { writeStderr } from '../io/io.js';
+import { listResearchProcessors, PROCESSORS, runResearch, getResearchResult, getResearchStatus } from '../services/research.js';
+export const ResearchProcessorSchema = z.object({
+    name: z.string(),
+});
+export const ResearchOutputSchema = z.object({
+    content: z.unknown().optional(),
+    basis: z.array(z.unknown()).optional(),
+}).nullable();
+export const ResearchDataSchema = z.union([
+    z.object({ processors: z.array(ResearchProcessorSchema), count: z.number().int().nonnegative() }),
+    z.object({ run_id: z.string(), processor: z.string(), output: ResearchOutputSchema, path: z.string().optional() }),
+    z.object({ run_id: z.string(), status: z.string(), error: z.unknown().optional(), warnings: z.array(z.unknown()).optional() }),
+    z.object({ run_id: z.string(), output: ResearchOutputSchema, path: z.string().optional() }),
+]);
+export default class Research extends BaseCommand {
+    static errors = [ErrorCode.UsageRequired, ErrorCode.UsageInvalid, ErrorCode.UsageUnknownFlag, ErrorCode.FileNotFound, ErrorCode.FileReadFailed, ErrorCode.FileWriteFailed, ErrorCode.ApiUnauthorized, ErrorCode.ApiForbidden, ErrorCode.ApiRateLimited, ErrorCode.GateInvalidResponse, ErrorCode.NetworkError, ErrorCode.NetworkTimeout, ErrorCode.ServiceUnavailable, ErrorCode.ResearchInputInvalid, ErrorCode.ResearchTaskFailed, ErrorCode.ResearchRunNotFound, ErrorCode.ResearchTimeout, ErrorCode.ResearchApiKeyMissing];
+    static summary = 'Run deep web research tasks';
+    static description = 'Run Parallel Task API research tasks, list processors, check status, or fetch completed results.';
+    static examples = [
+        '<%= config.bin %> research "HVAC industry market report" -o hvac.md',
+        '<%= config.bin %> research "Stripe" --output-schema "founding year and total funding" -p base',
+        '<%= config.bin %> research --processors',
+        '<%= config.bin %> research --status trun_xxx',
+        '<%= config.bin %> research --result trun_xxx -o out.md',
+    ];
+    static aliases = ['r'];
+    static flags = {
+        processors: Flags.boolean({ description: 'List available processor tiers.', default: false }),
+        status: Flags.string({ description: 'Check task run status.' }),
+        result: Flags.string({ description: 'Fetch completed task result.' }),
+        output: Flags.string({ char: 'o', description: 'Output path.' }),
+        processor: Flags.string({ char: 'p', description: 'Processor tier.', options: [...PROCESSORS], default: 'pro' }),
+        text: Flags.boolean({ description: 'Request text output schema.', default: false }),
+        schema: Flags.string({ description: 'JSON Schema file for structured output.' }),
+        'output-schema': Flags.string({ description: 'Inline schema description.' }),
+        'input-json': Flags.string({ description: 'JSON input instead of text.' }),
+        'input-file': Flags.string({ description: 'JSON input file.' }),
+        'include-domains': Flags.string({ description: 'Only use these domains, comma-separated.' }),
+        'exclude-domains': Flags.string({ description: 'Exclude these domains, comma-separated.' }),
+        'after-date': Flags.string({ description: 'Filter content after this date.' }),
+        location: Flags.string({ description: 'ISO country code for geo-targeting.' }),
+        metadata: Flags.string({ description: 'Metadata as JSON or key=val,key=val.' }),
+        'follow-up': Flags.string({ description: 'Follow up on a previous run.' }),
+        'no-basis': Flags.boolean({ description: 'Exclude citations and reasoning from human/file output.', default: false }),
+    };
+    static args = {
+        query: Args.string({ description: 'Research question or topic.', required: false, multiple: true }),
+    };
+    static enableJsonFlag = true;
+    static strict = true;
+    async execute() {
+        const { args, flags } = await this.parse(Research);
+        if (flags.processors)
+            return listResearchProcessors();
+        if (flags.status)
+            return getResearchStatus({ runId: flags.status, timeoutSeconds: flags.timeout });
+        if (flags.result)
+            return getResearchResult({ runId: flags.result, output: flags.output, noBasis: flags['no-basis'], timeoutSeconds: flags.timeout });
+        const query = args.query?.join(' ').trim() ?? '';
+        if (!query)
+            throw new EscliError('usage: escli research "query" -o output.md', { code: ErrorCode.UsageRequired, exitCode: ExitCodes.Usage });
+        if (!flags.quiet && !flags.json)
+            await writeStderr(`  ▸ submitting task (processor=${flags.processor})...\n`);
+        return runResearch({
+            query,
+            processor: flags.processor,
+            output: flags.output,
+            text: flags.text,
+            schema: flags.schema,
+            outputSchema: flags['output-schema'],
+            inputJson: flags['input-json'],
+            inputFile: flags['input-file'],
+            includeDomains: flags['include-domains'],
+            excludeDomains: flags['exclude-domains'],
+            afterDate: flags['after-date'],
+            location: flags.location,
+            metadata: flags.metadata,
+            followUp: flags['follow-up'],
+            noBasis: flags['no-basis'],
+            quiet: flags.quiet || flags.json,
+            timeoutSeconds: flags.timeout,
+        });
+    }
+}
+//# sourceMappingURL=research.js.map