@lotagate/cli 0.1.22 → 0.1.23

package/dist/infrastructure/agent-sdk/tool-calling-model-client.js

@@ -1,447 +0,0 @@
-import { SdkErrorCode } from '@lotagate/sdk';
-import { AssistantDeltaNormalizer } from '../../domain/runtime/assistant-delta-normalizer.js';
-/**
- * Adapts the published SDK client to the Agent SDK model port and makes the
- * intended tool-calling mode explicit for gateways that do not infer it from
- * the presence of `tools` alone.
- */
-export function createToolCallingModelClient(client, diagnostics = {}) {
-    const create = ((request, requestOptions) => {
-        if (request.stream === true) {
-            const stream = client.chat.completions.create(withAutomaticToolChoice({ ...request, stream: true }), requestOptions);
-            return observeStream(client, request, requestOptions, stream, request.model, diagnostics.onComplete);
-        }
-        return observeCompletion(client.chat.completions.create(withAutomaticToolChoice({ ...request, stream: false }), requestOptions), request.model, diagnostics.onComplete);
-    });
-    return { chat: { completions: { create } } };
-}
-async function observeCompletion(responsePromise, model, onComplete) {
-    const response = normalizeCompletionResponse(await responsePromise);
-    const message = response.choices[0]?.message;
-    onComplete?.({
-        model,
-        stream: false,
-        contentLength: textLength(message?.content),
-        toolCallCount: message?.tool_calls?.length ?? 0,
-        toolNames: (message?.tool_calls ?? []).map((call) => call.function.name),
-        ...(response.usage === undefined ? {} : { usage: mapUsage(response.usage) }),
-        ...(response.choices[0]?.finish_reason === undefined ? {} : { finishReason: response.choices[0].finish_reason }),
-    });
-    return response;
-}
-async function* observeStream(client, request, requestOptions, stream, model, onComplete) {
-    let contentLength = 0;
-    let finishReason;
-    const toolNames = new Set();
-    const toolCallIds = new Set();
-    const toolCallBuffer = new ToolCallStreamBuffer(request.tools);
-    let emittedMeaningfulFrame = false;
-    let usage;
-    let lastChunk;
-    let emittedBufferedToolCalls = false;
-    const deltaNormalizer = new AssistantDeltaNormalizer();
-    try {
-        for await (const rawChunk of stream) {
-            const normalizedChunk = normalizeChunkContent(rawChunk, deltaNormalizer);
-            const buffered = toolCallBuffer.consume(normalizedChunk);
-            const chunk = buffered.chunk;
-            const choice = chunk.choices[0];
-            if (chunk.usage !== undefined)
-                usage = mapUsage(chunk.usage);
-            const content = textLength(choice?.delta.content);
-            contentLength += content;
-            finishReason = choice?.finish_reason ?? finishReason;
-            if (content > 0 || buffered.hadToolCalls)
-                emittedMeaningfulFrame = true;
-            if (choice?.finish_reason === 'tool_calls' && !emittedBufferedToolCalls) {
-                const completed = toolCallBuffer.flush(chunk);
-                recordToolCalls(completed, toolCallIds, toolNames);
-                emittedBufferedToolCalls = true;
-                yield chunk;
-                yield completed;
-            }
-            else {
-                yield chunk;
-            }
-            lastChunk = chunk;
-        }
-        if (!emittedBufferedToolCalls && lastChunk !== undefined && toolCallBuffer.hasCalls()) {
-            const completed = toolCallBuffer.flush(lastChunk);
-            recordToolCalls(completed, toolCallIds, toolNames);
-            yield completed;
-        }
-    }
-    catch (error) {
-        if (!emittedMeaningfulFrame && isSseParseError(error) && requestOptions?.signal?.aborted !== true) {
-            const response = await client.chat.completions.create(withAutomaticToolChoice({ ...request, stream: false }), requestOptions);
-            if (response.usage !== undefined)
-                usage = mapUsage(response.usage);
-            const message = response.choices[0]?.message;
-            const bufferedContent = textLength(message?.content);
-            contentLength += bufferedContent;
-            for (const call of message?.tool_calls ?? []) {
-                if (call.id.length > 0)
-                    toolCallIds.add(call.id);
-                if (call.function.name.length > 0)
-                    toolNames.add(call.function.name);
-            }
-            finishReason = response.choices[0]?.finish_reason ?? finishReason;
-            yield bufferedResponseChunk(response);
-            return;
-        }
-        throw error;
-    }
-    finally {
-        onComplete?.({ model, stream: true, contentLength, toolCallCount: toolCallIds.size || toolNames.size, toolNames: [...toolNames], ...(finishReason === undefined ? {} : { finishReason }), ...(usage === undefined ? {} : { usage }) });
-    }
-}
-function withAutomaticToolChoice(request) {
-    return request.tools === undefined || request.tools.length === 0
-        ? request
-        : { ...request, tool_choice: 'auto' };
-}
-function bufferedResponseChunk(response) {
-    const normalized = normalizeCompletionResponse(response);
-    const choice = normalized.choices[0];
-    const message = choice?.message;
-    return {
-        id: normalized.id,
-        object: 'chat.completion.chunk',
-        created: normalized.created,
-        model: normalized.model,
-        choices: [{
-                index: choice?.index ?? 0,
-                delta: {
-                    role: 'assistant',
-                    content: textContent(message?.content),
-                    ...(message?.tool_calls === undefined ? {} : {
-                        tool_calls: message.tool_calls.map((call, index) => ({ ...call, index })),
-                    }),
-                },
-                ...(choice?.finish_reason === undefined ? {} : { finish_reason: choice.finish_reason }),
-            }],
-        ...(normalized.usage === undefined ? {} : { usage: normalized.usage }),
-    };
-}
-/**
- * Some gateways encode streamed assistant text as content parts. The
- * published Agent SDK consumes the portable string form for stream deltas, so
- * normalize that provider representation at the CLI boundary without
- * changing the external SDK contracts.
- */
-function normalizeChunkContent(chunk, deltaNormalizer) {
-    return {
-        ...chunk,
-        choices: chunk.choices.map((choice) => {
-            const content = choice.delta.content;
-            const normalizedContent = Array.isArray(content)
-                ? deltaNormalizer.normalize(textContent(content))
-                : typeof content === 'string'
-                    ? deltaNormalizer.normalize(content)
-                    : content;
-            const rawDelta = choice.delta;
-            const providerToolCalls = [
-                ...(Array.isArray(content) ? extractProviderToolCalls(content) : []),
-                ...extractLegacyFunctionCall(rawDelta['function_call'], 0),
-            ];
-            const normalizedChoice = normalizedContent === content && providerToolCalls.length === 0 ? choice : {
-                ...choice,
-                delta: {
-                    ...choice.delta,
-                    ...(normalizedContent === content ? {} : { content: normalizedContent }),
-                    ...(providerToolCalls.length === 0 ? {} : { tool_calls: [...(choice.delta.tool_calls ?? []), ...providerToolCalls] }),
-                },
-            };
-            return normalizedChoice;
-        }),
-    };
-}
-/**
- * Gateways can emit several overlapping tool-call frames, especially when a
- * response contains multiple tools. Buffer them at the CLI boundary and emit
- * one complete frame so the external Agent SDK never concatenates duplicated
- * JSON fragments into an invalid argument payload.
- */
-class ToolCallStreamBuffer {
-    knownNames;
-    calls = new Map();
-    order = [];
-    keysByPosition = new Map();
-    constructor(tools) {
-        this.knownNames = new Set((tools ?? []).flatMap((tool) => getToolNames(tool)));
-    }
-    consume(chunk) {
-        let hadToolCalls = false;
-        const choices = chunk.choices.map((choice) => {
-            const toolCalls = choice.delta.tool_calls;
-            if (toolCalls === undefined || toolCalls.length === 0)
-                return choice;
-            hadToolCalls = true;
-            toolCalls.forEach((call, position) => {
-                if (isRecord(call))
-                    this.append(call, position);
-            });
-            const delta = { ...choice.delta };
-            delete delta.tool_calls;
-            return { ...choice, delta };
-        });
-        return { chunk: { ...chunk, choices }, hadToolCalls };
-    }
-    hasCalls() { return this.order.length > 0; }
-    flush(chunk) {
-        const toolCalls = this.order.map((key, index) => {
-            const call = this.calls.get(key);
-            return {
-                id: call.id || `tool-call-${index}`,
-                type: call.type,
-                function: { name: call.name, arguments: call.arguments },
-                ...(call.providerMetadata === undefined ? {} : { provider_metadata: call.providerMetadata }),
-            };
-        });
-        const choices = chunk.choices.map((choice, index) => index === 0
-            ? { ...choice, delta: { ...choice.delta, tool_calls: toolCalls } }
-            : choice);
-        return { ...chunk, choices };
-    }
-    append(call, position) {
-        const id = toolCallId(call);
-        const type = toolCallType(call);
-        const nameFragment = toolCallName(call);
-        const argumentFragment = toolCallArguments(call);
-        const providerMetadata = readProviderMetadata(call);
-        const slot = toolCallSlot(call, position);
-        const key = this.keysByPosition.get(slot) ?? toolCallKey(id, slot);
-        this.keysByPosition.set(slot, key);
-        const current = this.calls.get(key);
-        const name = appendToolFragment(current?.name ?? '', nameFragment, this.knownNames);
-        const args = appendToolArguments(current?.arguments ?? '', argumentFragment);
-        if (current === undefined) {
-            this.calls.set(key, { id, type, name, arguments: args, ...(providerMetadata === undefined ? {} : { providerMetadata }) });
-            this.order.push(key);
-            return;
-        }
-        const nextProviderMetadata = current.providerMetadata ?? providerMetadata;
-        this.calls.set(key, {
-            id: current.id.length === 0 && id.length > 0 ? id : current.id,
-            type: type || current.type,
-            name: current.name + name,
-            arguments: args,
-            ...(nextProviderMetadata === undefined ? {} : { providerMetadata: nextProviderMetadata }),
-        });
-    }
-}
-function readProviderMetadata(value) {
-    if (!isRecord(value))
-        return undefined;
-    const metadata = value['provider_metadata'] ?? value['providerMetadata'];
-    if (isRecord(metadata))
-        return metadata;
-    const signature = value['thoughtSignature'] ?? value['thought_signature'];
-    return typeof signature === 'string' && signature.length > 0
-        ? { google: { thought_signature: signature } }
-        : undefined;
-}
-function toolCallSlot(call, position) {
-    const index = call.index;
-    return typeof index === 'number' && Number.isInteger(index) ? index : position;
-}
-function toolCallKey(id, slot) {
-    return id.length > 0 ? `id:${id}` : `index:${slot}`;
-}
-function toolCallId(call) {
-    const value = call;
-    if (!isRecord(value))
-        return '';
-    return typeof value['id'] === 'string' ? value['id'] : '';
-}
-function toolCallType(call) {
-    const value = call;
-    if (!isRecord(value))
-        return 'function';
-    return typeof value['type'] === 'string' && value['type'].length > 0 ? value['type'] : 'function';
-}
-function toolCallName(call) {
-    const value = call;
-    if (!isRecord(value))
-        return '';
-    return isRecord(value['function']) && typeof value['function']['name'] === 'string' ? value['function']['name'] : '';
-}
-function toolCallArguments(call) {
-    const value = call;
-    if (!isRecord(value))
-        return '';
-    return isRecord(value['function']) && typeof value['function']['arguments'] === 'string' ? value['function']['arguments'] : '';
-}
-function appendToolFragment(emitted, fragment, knownNames) {
-    if (fragment.length === 0)
-        return '';
-    if (fragment === emitted)
-        return '';
-    if (knownNames !== undefined && knownNames.has(fragment) && fragment.startsWith(emitted))
-        return fragment.slice(emitted.length);
-    if (fragment.startsWith(emitted) && emitted.length > 0)
-        return fragment.slice(emitted.length);
-    return fragment;
-}
-function appendToolArguments(emitted, fragment) {
-    if (fragment.length === 0)
-        return emitted;
-    if (emitted.length === 0 || fragment === emitted)
-        return emitted.length === 0 ? fragment : emitted;
-    if (fragment.startsWith(emitted))
-        return fragment;
-    const mergedObject = mergeJsonObjectFragments(emitted, fragment);
-    if (mergedObject !== undefined)
-        return mergedObject;
-    return emitted + fragment;
-}
-function mergeJsonObjectFragments(emitted, fragment) {
-    if (emitted.length === 0 || fragment.length === 0)
-        return undefined;
-    const current = parseJsonObject(emitted);
-    const next = parseJsonObject(fragment);
-    if (current === undefined || next === undefined)
-        return undefined;
-    return JSON.stringify({ ...current, ...next });
-}
-function parseJsonObject(value) {
-    try {
-        const parsed = JSON.parse(value);
-        return isRecord(parsed) ? parsed : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function recordToolCalls(chunk, ids, names) {
-    for (const call of chunk.choices[0]?.delta.tool_calls ?? []) {
-        const id = toolCallId(call);
-        const name = toolCallName(call);
-        if (id.length > 0)
-            ids.add(id);
-        if (name.length > 0)
-            names.add(name);
-    }
-}
-function getToolNames(tool) {
-    if ('function' in tool && typeof tool.function.name === 'string')
-        return [tool.function.name];
-    if ('name' in tool && typeof tool.name === 'string')
-        return [tool.name];
-    if ('functionDeclarations' in tool)
-        return tool.functionDeclarations.flatMap((declaration) => typeof declaration.name === 'string' ? [declaration.name] : []);
-    return [];
-}
-function normalizeCompletionResponse(response) {
-    return {
-        ...response,
-        choices: response.choices.map((choice) => ({
-            ...choice,
-            message: normalizeAssistantMessage(choice.message),
-        })),
-    };
-}
-function normalizeAssistantMessage(message) {
-    const rawMessage = message;
-    const providerToolCalls = [
-        ...(Array.isArray(message.content) ? extractProviderToolCalls(message.content) : []),
-        ...extractLegacyFunctionCall(rawMessage['function_call'], 0),
-    ];
-    if (!Array.isArray(message.content) && providerToolCalls.length === 0)
-        return message;
-    return {
-        ...message,
-        ...(Array.isArray(message.content) ? { content: textContent(message.content) } : {}),
-        ...(providerToolCalls.length === 0 ? {} : { tool_calls: [...(message.tool_calls ?? []), ...providerToolCalls] }),
-    };
-}
-function extractProviderToolCalls(content) {
-    const calls = [];
-    for (const [index, part] of content.entries()) {
-        if (typeof part !== 'object' || part === null)
-            continue;
-        if ('functionCall' in part && isRecord(part.functionCall) && typeof part.functionCall['name'] === 'string') {
-            const args = part.functionCall['args'];
-            calls.push({
-                id: typeof part.functionCall['id'] === 'string' && part.functionCall['id'].length > 0 ? part.functionCall['id'] : `provider-call-${index}`,
-                type: 'function',
-                function: { name: part.functionCall['name'], arguments: serializeToolArguments(args) },
-                ...(readProviderMetadata(part) === undefined ? {} : { provider_metadata: readProviderMetadata(part) }),
-            });
-            continue;
-        }
-        if ('tool_use' in part && isRecord(part.tool_use) && typeof part.tool_use['name'] === 'string') {
-            const input = part.tool_use['input'];
-            calls.push({
-                id: typeof part.tool_use['id'] === 'string' && part.tool_use['id'].length > 0 ? part.tool_use['id'] : `provider-call-${index}`,
-                type: 'function',
-                function: { name: part.tool_use['name'], arguments: JSON.stringify(input ?? {}) },
-                ...(readProviderMetadata(part) === undefined ? {} : { provider_metadata: readProviderMetadata(part) }),
-            });
-        }
-    }
-    return calls;
-}
-function extractLegacyFunctionCall(value, index) {
-    if (!isRecord(value) || typeof value['name'] !== 'string')
-        return [];
-    const args = value['arguments'];
-    return [{
-            id: typeof value['id'] === 'string' && value['id'].length > 0 ? value['id'] : `provider-call-${index}`,
-            type: 'function',
-            function: { name: value['name'], arguments: serializeToolArguments(args) },
-            ...(readProviderMetadata(value) === undefined ? {} : { provider_metadata: readProviderMetadata(value) }),
-        }];
-}
-function serializeToolArguments(value) {
-    if (value === undefined)
-        return '';
-    if (typeof value === 'string')
-        return value;
-    try {
-        return JSON.stringify(value);
-    }
-    catch {
-        return '';
-    }
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function isSseParseError(error) {
-    return typeof error === 'object'
-        && error !== null
-        && 'errorCode' in error
-        && error.errorCode === SdkErrorCode.ResponseParseError;
-}
-function textContent(content) {
-    if (typeof content === 'string')
-        return content;
-    if (!Array.isArray(content))
-        return '';
-    return content.reduce((result, part) => {
-        if (typeof part !== 'object' || part === null || !('text' in part))
-            return result;
-        const text = part.text;
-        return result + (typeof text === 'string' ? text : '');
-    }, '');
-}
-function textLength(content) {
-    if (typeof content === 'string')
-        return content.length;
-    if (!Array.isArray(content))
-        return 0;
-    return content.reduce((total, part) => {
-        if (typeof part !== 'object' || part === null || !('text' in part))
-            return total;
-        const text = part.text;
-        return total + (typeof text === 'string' ? text.length : 0);
-    }, 0);
-}
-function mapUsage(usage) {
-    return {
-        ...(typeof usage.prompt_tokens === 'number' ? { promptTokens: usage.prompt_tokens } : {}),
-        ...(typeof usage.completion_tokens === 'number' ? { completionTokens: usage.completion_tokens } : {}),
-        ...(typeof usage.total_tokens === 'number' ? { totalTokens: usage.total_tokens } : {}),
-    };
-}

package/dist/infrastructure/cache/cache-policy.d.ts

@@ -1,7 +0,0 @@
-export interface CachePolicy {
-    enabled: boolean;
-    modelCatalogTtlMs: number;
-    maxEntryBytes: number;
-    maxTotalBytes: number;
-}
-export declare function resolveCachePolicy(env?: Readonly<Record<string, string | undefined>>): CachePolicy;

package/dist/infrastructure/cache/cache-policy.js

@@ -1,18 +0,0 @@
-export function resolveCachePolicy(env = process.env) {
-    return {
-        enabled: parseBoolean(env['LOTAGATE_CACHE_ENABLED'], true),
-        modelCatalogTtlMs: readBoundedEnvironmentInteger(env['LOTAGATE_MODEL_CACHE_TTL_SECONDS'], 300, 1, 86_400) * 1_000,
-        maxEntryBytes: readBoundedEnvironmentInteger(env['LOTAGATE_CACHE_MAX_ENTRY_BYTES'], 5 * 1024 * 1024, 1_024, 50 * 1024 * 1024),
-        maxTotalBytes: readBoundedEnvironmentInteger(env['LOTAGATE_CACHE_MAX_BYTES'], 50 * 1024 * 1024, 1 * 1024 * 1024, 500 * 1024 * 1024),
-    };
-}
-function parseBoolean(value, fallback) {
-    if (value === undefined)
-        return fallback;
-    if (value.trim().toLowerCase() === 'true')
-        return true;
-    if (value.trim().toLowerCase() === 'false')
-        return false;
-    return fallback;
-}
-import { readBoundedEnvironmentInteger } from '../config/environment-values.js';

package/dist/infrastructure/cache/file-cache-store.d.ts

@@ -1,17 +0,0 @@
-import type { CacheStore, CacheWriteOptions } from '../../ports/cache-store.js';
-import type { CachePolicy } from './cache-policy.js';
-export declare class FileCacheStore implements CacheStore {
-    private readonly root;
-    private readonly policy;
-    private readonly now;
-    private prunePromise;
-    constructor(root: string, policy: CachePolicy, now?: () => number);
-    get<T>(namespace: string, key: string): Promise<T | undefined>;
-    set<T>(namespace: string, key: string, value: T, options: CacheWriteOptions): Promise<void>;
-    delete(namespace: string, key: string): Promise<void>;
-    clear(namespace?: string): Promise<void>;
-    prune(): Promise<void>;
-    private schedulePrune;
-    private namespacePath;
-    private filePath;
-}

package/dist/infrastructure/cache/file-cache-store.js

@@ -1,121 +0,0 @@
-import crypto from 'node:crypto';
-import fsSync from 'node:fs';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { atomicWriteFile, withFileLock } from '../filesystem/atomic-file-store.js';
-import { isFileNotFound } from '../filesystem/fs-errors.js';
-import { readJsonFileBounded } from '../filesystem/bounded-json-reader.js';
-export class FileCacheStore {
-    root;
-    policy;
-    now;
-    prunePromise;
-    constructor(root, policy, now = Date.now) {
-        this.root = root;
-        this.policy = policy;
-        this.now = now;
-        try {
-            fsSync.mkdirSync(root, { recursive: true, mode: 0o700 });
-        }
-        catch { /* Cache is best effort and must not block CLI startup. */ }
-    }
-    async get(namespace, key) {
-        if (!this.policy.enabled)
-            return undefined;
-        const filePath = this.filePath(namespace, key);
-        try {
-            const envelope = await readJsonFileBounded(filePath, this.policy.maxEntryBytes);
-            if (envelope.schemaVersion !== 1 || envelope.namespace !== namespace || envelope.keyHash !== hashKey(namespace, key) || typeof envelope.expiresAt !== 'string')
-                return undefined;
-            if (Date.parse(envelope.expiresAt) <= this.now()) {
-                await this.delete(namespace, key);
-                return undefined;
-            }
-            return envelope.value;
-        }
-        catch (error) {
-            if (!isFileNotFound(error))
-                await this.delete(namespace, key).catch(() => undefined);
-            return undefined;
-        }
-    }
-    async set(namespace, key, value, options) {
-        if (!this.policy.enabled || options.ttlMs <= 0)
-            return;
-        const envelope = {
-            schemaVersion: 1,
-            namespace,
-            keyHash: hashKey(namespace, key),
-            createdAt: new Date(this.now()).toISOString(),
-            expiresAt: new Date(this.now() + options.ttlMs).toISOString(),
-            value,
-        };
-        const data = `${JSON.stringify(envelope)}\n`;
-        if (Buffer.byteLength(data, 'utf8') > this.policy.maxEntryBytes)
-            return;
-        const filePath = this.filePath(namespace, key);
-        await withFileLock(filePath, () => atomicWriteFile(filePath, data));
-        this.schedulePrune();
-    }
-    async delete(namespace, key) {
-        await fs.rm(this.filePath(namespace, key), { force: true });
-    }
-    async clear(namespace) {
-        await fs.rm(namespace === undefined ? this.root : this.namespacePath(namespace), { recursive: true, force: true });
-    }
-    async prune() {
-        if (!this.policy.enabled)
-            return;
-        const files = await listFiles(this.root);
-        const entries = [];
-        for (const filePath of files) {
-            try {
-                const stat = await fs.stat(filePath);
-                const value = await readJsonFileBounded(filePath, this.policy.maxEntryBytes);
-                if (value.schemaVersion !== 1 || typeof value.expiresAt !== 'string' || Date.parse(value.expiresAt) <= this.now()) {
-                    await fs.rm(filePath, { force: true });
-                    continue;
-                }
-                entries.push({ filePath, size: stat.size, modifiedAt: stat.mtimeMs });
-            }
-            catch {
-                await fs.rm(filePath, { force: true });
-            }
-        }
-        let total = entries.reduce((sum, entry) => sum + entry.size, 0);
-        for (const entry of entries.sort((left, right) => left.modifiedAt - right.modifiedAt)) {
-            if (total <= this.policy.maxTotalBytes)
-                break;
-            await fs.rm(entry.filePath, { force: true });
-            total -= entry.size;
-        }
-    }
-    schedulePrune() {
-        if (this.prunePromise !== undefined)
-            return;
-        this.prunePromise = this.prune().catch(() => undefined).finally(() => { this.prunePromise = undefined; });
-    }
-    namespacePath(namespace) { return path.join(this.root, encodeNamespace(namespace)); }
-    filePath(namespace, key) { return path.join(this.namespacePath(namespace), `${hashKey(namespace, key)}.json`); }
-}
-function hashKey(namespace, key) { return crypto.createHash('sha256').update(`${namespace}\0${key}`).digest('hex'); }
-function encodeNamespace(namespace) { return Buffer.from(namespace, 'utf8').toString('base64url'); }
-async function listFiles(root) {
-    try {
-        const entries = await fs.readdir(root, { withFileTypes: true });
-        const files = [];
-        for (const entry of entries) {
-            const candidate = path.join(root, entry.name);
-            if (entry.isDirectory())
-                files.push(...await listFiles(candidate));
-            else if (entry.isFile() && entry.name.endsWith('.json'))
-                files.push(candidate);
-        }
-        return files;
-    }
-    catch (error) {
-        if (isFileNotFound(error))
-            return [];
-        throw error;
-    }
-}

package/dist/infrastructure/clipboard/clipboard-adapter-factory.d.ts

@@ -1,11 +0,0 @@
-import type { ClipboardAdapter, ClipboardImage } from '../../ports/clipboard-adapter.js';
-import { type HostPlatformContext } from '../platform/host-platform.js';
-export declare function createClipboardAdapter(platform?: HostPlatformContext): ClipboardAdapter;
-export declare class ProcessClipboardAdapter implements ClipboardAdapter {
-    private readonly command;
-    private readonly args;
-    private readonly mimeType;
-    private readonly platform;
-    constructor(command: string, args: readonly string[], mimeType: string, platform?: HostPlatformContext);
-    readImage(): Promise<ClipboardImage | undefined>;
-}