@lotagate/cli 0.1.20 → 0.1.22

package/dist/presentation/tui/tui-goal-controller.js

@@ -0,0 +1,52 @@
+import { AuthenticationService } from '../../application/auth/authentication-service.js';
+import { loadExecutionConfig } from '../../application/config/execution-config.js';
+import { createLotaGateClient } from '../../infrastructure/sdk/lotagate-client-factory.js';
+import { RESOURCE_LIMITS } from '../../domain/runtime/resource-limits.js';
+import { runGoalLoop } from '../../application/orchestration/goal-runner.js';
+import { formatCommandHint, MODEL_SELECT_HINT, TRUST_GRANT_HINT } from '../../application/commands/command-hints.js';
+export async function runTuiGoal(options, objective, limits = {}) {
+    await runGoalLoopForTui(options, objective, true, limits);
+}
+export async function resumeTuiGoal(options) {
+    if (options.sessionId === undefined) {
+        options.write('No active session.');
+        return;
+    }
+    const state = await options.runtime.goalStore.get(options.sessionId);
+    if (state === undefined) {
+        options.write('No active goal.');
+        return;
+    }
+    await runGoalLoopForTui(options, state.objective, false);
+}
+async function runGoalLoopForTui(options, objective, replace, limits = {}) {
+    if (options.sessionId === undefined) {
+        options.write('No active session.');
+        return;
+    }
+    const identity = await options.runtime.projectTrust.inspect(options.cwd);
+    if (!await options.runtime.projectTrust.isTrusted(identity)) {
+        options.write(`Project is not trusted. ${formatCommandHint(TRUST_GRANT_HINT, 'tui')}`);
+        return;
+    }
+    const loaded = await loadExecutionConfig(options.runtime, options.cwd);
+    const model = options.model ?? loaded.config.model;
+    if (model === null) {
+        options.write(`No model is selected. ${formatCommandHint(MODEL_SELECT_HINT, 'tui')}`);
+        return;
+    }
+    const profile = options.profile ?? loaded.config.profile ?? AuthenticationService.defaultProfileName();
+    const credential = await options.runtime.auth.requireCredential(profile);
+    const goal = replace
+        ? await options.runtime.goalStore.replace(options.sessionId, { objective, maxTurns: RESOURCE_LIMITS.goalDefaultMaxTurns, maxDurationMs: RESOURCE_LIMITS.goalDefaultMaxDurationMs, ...limits })
+        : await resumeGoal(options.sessionId, options.runtime);
+    const client = createLotaGateClient(credential.profile, credential.apiKey);
+    await runGoalLoop({
+        runtime: options.runtime, sessionId: options.sessionId, objective: goal.objective, model, client,
+        runTurn: (prompt, callbacks) => options.runPrompt(prompt, callbacks),
+        onMessage: options.write,
+    });
+}
+async function resumeGoal(sessionId, runtime) {
+    return runtime.goalStore.resume(sessionId);
+}

package/dist/presentation/tui/tui-initial-model.d.ts

@@ -0,0 +1,3 @@
+import type { CliRuntime } from '../../bootstrap/runtime-factory.js';
+import type { CliConfig } from '../../domain/config/config-schema.js';
+export declare function resolveInitialModel(runtime: CliRuntime, cwd: string, config: CliConfig): Promise<string | null>;

package/dist/presentation/tui/tui-initial-model.js

@@ -0,0 +1,28 @@
+import { AuthenticationService } from '../../application/auth/authentication-service.js';
+import { CachedModelCatalog, modelCatalogCacheKey } from '../../application/model/cached-model-catalog.js';
+import { ModelCatalogAdapter } from '../../infrastructure/sdk/model-catalog-adapter.js';
+import { createLotaGateClient } from '../../infrastructure/sdk/lotagate-client-factory.js';
+import { selectInitialModel } from '../../application/model/initial-model-selection.js';
+export async function resolveInitialModel(runtime, cwd, config) {
+    if (config.model !== null && config.model.trim().length > 0)
+        return config.model;
+    const profileName = config.profile ?? AuthenticationService.defaultProfileName();
+    let credential;
+    try {
+        credential = await runtime.credentialStore.get(profileName);
+    }
+    catch (error) {
+        runtime.logger.warn('Unable to load credentials while selecting the initial model.', { reason: error instanceof Error ? error.message : String(error) });
+        return null;
+    }
+    if (credential === undefined)
+        return null;
+    try {
+        const catalog = new CachedModelCatalog(new ModelCatalogAdapter(createLotaGateClient(credential.profile, credential.apiKey)), runtime.cache, modelCatalogCacheKey(credential.profile.name, credential.profile.baseUrl), runtime.cachePolicy.modelCatalogTtlMs);
+        return await selectInitialModel(config.model, { list: () => catalog.listModels() }, (model) => runtime.configLoader.setGlobal('model', model));
+    }
+    catch (error) {
+        runtime.logger.warn('Unable to select the first model from the catalog.', { reason: error instanceof Error ? error.message : String(error) });
+        return null;
+    }
+}

package/dist/presentation/tui/tui-lifecycle-actions.d.ts

@@ -0,0 +1,13 @@
+import type { HookDefinition, HookEvent } from '../../domain/extensions/hook-manifest.js';
+import type { HookRuntime } from '../../infrastructure/extensions/hook-runtime.js';
+import type { InkTuiBridge } from './ink/tui-bridge.js';
+export interface TuiInterruptState {
+    lastInterruptAt: number;
+    exitArmedUntil: number;
+    printResumeCommandOnExit: boolean;
+}
+export declare function handleTuiInterrupt(state: TuiInterruptState, activeAbortController: AbortController | undefined, renderer: InkTuiBridge): TuiInterruptState;
+export declare function cancelTuiResponse(activeAbortController: AbortController | undefined, renderer: InkTuiBridge): void;
+export declare function runTuiHookEvent(hookRuntime: HookRuntime | undefined, hooks: readonly HookDefinition[], event: HookEvent, cwd: string, sessionId: string): Promise<void>;
+export declare function isAbortError(error: unknown): boolean;
+export declare function throwIfAborted(signal: AbortSignal): void;

package/dist/presentation/tui/tui-lifecycle-actions.js

@@ -0,0 +1,45 @@
+export function handleTuiInterrupt(state, activeAbortController, renderer) {
+    const now = Date.now();
+    if (now - state.lastInterruptAt < 75)
+        return state;
+    if (activeAbortController !== undefined && !activeAbortController.signal.aborted) {
+        activeAbortController.abort();
+        renderer.cancelled();
+        renderer.notice('Interrupted. Press Ctrl+C again within 2 seconds to exit.');
+        return { ...state, lastInterruptAt: now, exitArmedUntil: now + 2000 };
+    }
+    if (now <= state.exitArmedUntil) {
+        renderer.requestExit();
+        return { ...state, lastInterruptAt: now, printResumeCommandOnExit: true };
+    }
+    renderer.notice('Press Ctrl+C again within 2 seconds to exit.');
+    return { ...state, lastInterruptAt: now, exitArmedUntil: now + 2000 };
+}
+export function cancelTuiResponse(activeAbortController, renderer) {
+    if (activeAbortController === undefined)
+        return;
+    activeAbortController.abort();
+    renderer.cancelled();
+    renderer.notice('Stopping response…');
+}
+export async function runTuiHookEvent(hookRuntime, hooks, event, cwd, sessionId) {
+    if (hookRuntime === undefined || hooks.length === 0)
+        return;
+    await hookRuntime.runEvent(hooks, event, { sessionId, runId: `hook-${Date.now()}`, iteration: 0, cwd, workspaceRoot: cwd, maxResultBytes: 256 * 1024 });
+}
+export function isAbortError(error) {
+    if (!(error instanceof Error))
+        return false;
+    if (error.name === 'AbortError' || error.message.toLowerCase().includes('aborted'))
+        return true;
+    return error.cause !== undefined && isAbortError(error.cause);
+}
+export function throwIfAborted(signal) {
+    if (!signal.aborted)
+        return;
+    if (signal.reason instanceof Error && signal.reason.name === 'AbortError')
+        throw signal.reason;
+    const error = new Error(signal.reason instanceof Error && signal.reason.message.length > 0 ? signal.reason.message : 'The operation was aborted.');
+    error.name = 'AbortError';
+    throw error;
+}

package/dist/presentation/tui/tui-manual-compaction.d.ts

@@ -0,0 +1,18 @@
+import type { CliRuntime } from '../../bootstrap/runtime-factory.js';
+import type { SessionMetadata } from '../../domain/session/session.js';
+import type { CliAgentSessionStore } from '../../application/agent/agent-session-store.js';
+import type { TuiContextService } from './tui-context-service.js';
+import type { InkTuiBridge } from './ink/tui-bridge.js';
+export interface TuiManualCompactionOptions {
+    runtime: CliRuntime;
+    cwd: string;
+    session: SessionMetadata | undefined;
+    activeModel: string | null;
+    activeProfile: string | null;
+    activeResponse: boolean;
+    renderer: InkTuiBridge;
+    contextService: TuiContextService;
+    agentSessionStore: CliAgentSessionStore;
+    refreshContextUsage: () => Promise<void>;
+}
+export declare function compactManualTuiSession(options: TuiManualCompactionOptions): Promise<void>;

package/dist/presentation/tui/tui-manual-compaction.js

@@ -0,0 +1,31 @@
+import { AuthenticationService } from '../../application/auth/authentication-service.js';
+import { loadExecutionConfig } from '../../application/config/execution-config.js';
+import { createLotaGateClient } from '../../infrastructure/sdk/lotagate-client-factory.js';
+import { CliError } from '../../domain/errors/cli-error.js';
+import { CLI_ERROR_CODES } from '../../domain/errors/error-codes.js';
+import { MODEL_SELECT_HINT } from '../../application/commands/command-hints.js';
+import { compactTuiSession } from './tui-context-compaction.js';
+export async function compactManualTuiSession(options) {
+    if (options.activeResponse)
+        throw new Error('Stop the active response before compacting the session.');
+    if (options.session === undefined) {
+        options.renderer.notice('No active session.');
+        return;
+    }
+    const loaded = await loadExecutionConfig(options.runtime, options.cwd);
+    const model = options.session.model ?? options.activeModel ?? loaded.config.model;
+    if (model === null)
+        throw new CliError(CLI_ERROR_CODES.MODEL_NOT_FOUND, 'No model is selected.', { category: 'model', userMessage: 'No model is selected.', hint: MODEL_SELECT_HINT });
+    const profile = options.session.profile ?? options.activeProfile ?? loaded.config.profile ?? AuthenticationService.defaultProfileName();
+    const credential = await options.runtime.auth.requireCredential(profile);
+    const contextWindow = await options.contextService.getModelContextWindow(model, profile);
+    options.renderer.activity('Compacting context manually…', 0);
+    try {
+        const compacted = await compactTuiSession(options.runtime, options.agentSessionStore, options.session.id, createLotaGateClient(credential.profile, credential.apiKey), model, contextWindow, (error) => options.runtime.logger.warn('Context summarization failed; using fallback summary.', { reason: error instanceof Error ? error.message : String(error) }));
+        options.renderer.transcriptNotice(compacted ? 'Context compacted manually.' : 'No conversation to compact.');
+        await options.refreshContextUsage();
+    }
+    finally {
+        options.renderer.clearActivity();
+    }
+}

package/dist/presentation/tui/tui-media-model-selection.d.ts

@@ -0,0 +1,12 @@
+import type { CommandInvocation } from '../../application/commands/command-contract.js';
+import type { TuiChoice } from './ink/tui-bridge.js';
+import type { loadModelCatalog } from '../../application/model/model-catalog-service.js';
+export type MediaModelCategory = 'image' | 'speech' | 'transcription' | 'translation' | 'video';
+type ModelCatalog = Awaited<ReturnType<typeof loadModelCatalog>>;
+export interface TuiMediaModelSelectionDependencies {
+    readonly loadModels: () => Promise<ModelCatalog>;
+    readonly selectModel: (title: string, choices: readonly TuiChoice[]) => Promise<string | undefined>;
+}
+/** Adds a request-only media model selection without changing persisted configuration. */
+export declare function prepareTuiMediaInvocation(invocation: CommandInvocation, dependencies: TuiMediaModelSelectionDependencies): Promise<CommandInvocation | undefined>;
+export {};

package/dist/presentation/tui/tui-media-model-selection.js

@@ -0,0 +1,38 @@
+import { CliError } from '../../domain/errors/cli-error.js';
+import { CLI_ERROR_CODES } from '../../domain/errors/error-codes.js';
+const MEDIA_MODEL_CATEGORY_BY_ACTION = {
+    'image.generate': 'image',
+    'image.edit': 'image',
+    'audio.speech': 'speech',
+    'audio.transcribe': 'transcription',
+    'audio.translate': 'translation',
+    'video.generate': 'video',
+};
+/** Adds a request-only media model selection without changing persisted configuration. */
+export async function prepareTuiMediaInvocation(invocation, dependencies) {
+    const category = MEDIA_MODEL_CATEGORY_BY_ACTION[invocation.action.id];
+    if (category === undefined || invocation.options.has('model'))
+        return invocation;
+    const catalog = await dependencies.loadModels();
+    const candidates = catalog.data.filter((model) => model['model_category'] === category);
+    if (candidates.length === 0) {
+        throw new CliError(CLI_ERROR_CODES.MODEL_NOT_FOUND, `No ${category} models are available.`, {
+            category: 'model',
+            userMessage: `No ${category} models are available for this command.`,
+            details: { category },
+        });
+    }
+    const selected = await dependencies.selectModel(`Select ${category} model`, candidates.map((model) => ({ value: model.id, label: model.id })));
+    if (selected === undefined)
+        return undefined;
+    const selectedModel = candidates.find((model) => model.id === selected);
+    if (selectedModel === undefined) {
+        throw new CliError(CLI_ERROR_CODES.MODEL_NOT_FOUND, 'The selected media model is no longer available.', {
+            category: 'model',
+            userMessage: 'The selected media model is no longer available. Refresh the model list and try again.',
+        });
+    }
+    const options = new Map(invocation.options);
+    options.set('model', selectedModel.id);
+    return { ...invocation, options };
+}

package/dist/presentation/tui/tui-prompt-dispatcher.d.ts

@@ -0,0 +1,16 @@
+import type { Logger } from '../../ports/logger.js';
+import type { AttachmentPayload } from '../../domain/session/attachment.js';
+import type { PendingAttachmentStore } from '../../application/chat/pending-attachment-store.js';
+import type { InkTuiBridge } from './ink/tui-bridge.js';
+import type { TuiCommandContext } from './tui-command-context.js';
+import type { TuiCommandHost } from './tui-command-executor.js';
+export interface TuiPromptDispatcherOptions {
+    renderer: InkTuiBridge;
+    logger: Logger;
+    commandHost: TuiCommandHost;
+    pendingAttachments: PendingAttachmentStore;
+    commandContext: () => TuiCommandContext;
+    sendPrompt: (input: string, attachments: readonly AttachmentPayload[]) => Promise<unknown>;
+    resetActiveAbortController: () => void;
+}
+export declare function dispatchTuiPrompt(input: string, options: TuiPromptDispatcherOptions): Promise<boolean>;

package/dist/presentation/tui/tui-prompt-dispatcher.js

@@ -0,0 +1,38 @@
+import { asCliError } from '../../domain/errors/cli-error.js';
+import { parseCommandInvocation, tokenizeCommandInput } from '../../application/commands/command-parser.js';
+import { COMMAND_REGISTRY } from '../../application/commands/command-runtime.js';
+import { formatCliErrorMessage } from '../../application/commands/command-hints.js';
+import { executeTuiCommand } from './tui-command-executor.js';
+export async function dispatchTuiPrompt(input, options) {
+    if (input.trimStart().startsWith('/'))
+        return dispatchSlashCommand(input, options);
+    options.logger.info('Interactive prompt started.', { promptLength: input.length, attachmentCount: options.pendingAttachments.size });
+    try {
+        await options.sendPrompt(input, options.pendingAttachments.list());
+        options.logger.info('Interactive prompt completed.', { promptLength: input.length });
+    }
+    catch (error) {
+        options.resetActiveAbortController();
+        options.renderer.failed();
+        const cliError = asCliError(error);
+        options.logger.error('Prompt execution failed.', { code: cliError.code, category: cliError.category, ...(cliError.details ?? {}) });
+        options.renderer.error(formatCliErrorMessage(cliError, 'tui'));
+    }
+    return false;
+}
+async function dispatchSlashCommand(input, options) {
+    options.renderer.command(input);
+    try {
+        const invocation = parseCommandInvocation(tokenizeCommandInput(input.trimStart().slice(1)), 'tui', COMMAND_REGISTRY);
+        options.logger.info('Slash command started.', { command: invocation.action.id });
+        const exit = await executeTuiCommand(invocation, options.commandHost, options.commandContext());
+        options.logger.info('Slash command completed.', { command: invocation.action.id, exit });
+        return exit;
+    }
+    catch (error) {
+        const cliError = asCliError(error);
+        options.logger.error('Slash command failed.', { code: cliError.code, category: cliError.category });
+        options.renderer.error(formatCliErrorMessage(cliError, 'tui'));
+        return false;
+    }
+}

package/dist/presentation/tui/tui-skill-controller.d.ts

@@ -0,0 +1,11 @@
+import type { SkillManifest } from '../../domain/extensions/skill-manifest.js';
+import type { ExtensionScope } from '../../domain/extensions/extension-scope.js';
+import type { TuiCommandContext } from './tui-command-context.js';
+import { type ScopedSkill } from '../../infrastructure/extensions/skill-manager.js';
+import type { SkillRootScope } from '../../infrastructure/extensions/skill-roots.js';
+export interface TuiSkillControllerOptions {
+    globalConfigDir: string;
+    skillRootScopes: readonly SkillRootScope[];
+    runPrompt: (prompt: string, skill?: SkillManifest) => Promise<string>;
+}
+export declare function runTuiSkill(options: TuiSkillControllerOptions, name: string, args: readonly string[], context: TuiCommandContext, scope?: ExtensionScope, availableSkills?: readonly ScopedSkill[]): Promise<void>;

package/dist/presentation/tui/tui-skill-controller.js

@@ -0,0 +1,13 @@
+import path from 'node:path';
+import { SkillManager } from '../../infrastructure/extensions/skill-manager.js';
+export async function runTuiSkill(options, name, args, context, scope, availableSkills) {
+    const skills = availableSkills ?? await new SkillManager(path.join(options.globalConfigDir, 'skills-state.json')).listScoped(options.skillRootScopes, { includeShadowed: true });
+    const skill = skills.find((item) => (item.skillKey === name || item.name === name) && (scope === undefined || item.scope === scope));
+    if (skill === undefined || !skill.enabled || !skill.userInvocable) {
+        context.write(`Skill unavailable: ${name}`);
+        return;
+    }
+    const requestedScope = args.join(' ').trim();
+    const prompt = requestedScope.length === 0 ? skill.body : `${skill.body}\n\nRequested scope: ${requestedScope}`;
+    await options.runPrompt(prompt, skill);
+}

package/dist/presentation/tui/tui-tool-approval.d.ts

@@ -0,0 +1,22 @@
+import type { CliRuntime } from '../../bootstrap/runtime-factory.js';
+import type { ToolApprovalRequest } from '@lotagate/agent-sdk';
+import { ToolApprovalService, type CliApprovalMode, type ToolApprovalDecision } from '../../application/security/tool-approval-service.js';
+import type { SkillScopeStore } from '../../application/extensions/skill-scope-store.js';
+import type { WorkspacePermissionPolicy } from '../../domain/workspace/workspace-settings.js';
+import type { InkTuiBridge } from './ink/tui-bridge.js';
+export interface TuiToolApprovalHost {
+    readonly renderer: InkTuiBridge;
+    readonly runtime: CliRuntime;
+    getSessionId(): string | undefined;
+    getActiveSignal(): AbortSignal | undefined;
+}
+/** Owns the TUI adapter around the application-layer approval service. */
+export declare class TuiToolApprovalCoordinator {
+    private readonly host;
+    constructor(host: TuiToolApprovalHost);
+    ask(request: ToolApprovalRequest): Promise<boolean>;
+    create(mode: CliApprovalMode, trustedProject: boolean, workspaceRoot: string, skillScopes?: SkillScopeStore, workspacePermissions?: WorkspacePermissionPolicy): ToolApprovalService;
+    remember(workspaceRoot: string, request: ToolApprovalRequest): Promise<void>;
+    audit(decision: ToolApprovalDecision): Promise<void>;
+    rememberFailure(error: unknown): void;
+}

package/dist/presentation/tui/tui-tool-approval.js

@@ -0,0 +1,73 @@
+import { ToolApprovalService } from '../../application/security/tool-approval-service.js';
+import { permissionRuleForRequest } from '../../application/security/workspace-permission-policy.js';
+import { formatShellCommandForDisplay, formatToolActivityName } from '../../application/agent/tool-display.js';
+/** Owns the TUI adapter around the application-layer approval service. */
+export class TuiToolApprovalCoordinator {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    async ask(request) {
+        this.host.renderer.status('Waiting for approval');
+        try {
+            return await this.host.renderer.confirmTool(request.toolName, describeToolApproval(request));
+        }
+        finally {
+            const signal = this.host.getActiveSignal();
+            if (signal !== undefined && !signal.aborted)
+                this.host.renderer.status('Thinking');
+        }
+    }
+    create(mode, trustedProject, workspaceRoot, skillScopes, workspacePermissions) {
+        return new ToolApprovalService({
+            mode,
+            trustedProject,
+            ...(skillScopes === undefined ? {} : { skillScopes }),
+            ...(workspacePermissions === undefined ? {} : { workspacePermissions }),
+            prompt: (request) => this.ask(request),
+            ...(trustedProject ? { rememberApproval: (request) => this.remember(workspaceRoot, request) } : {}),
+            ...(trustedProject ? { onRememberApprovalFailure: (_request, error) => this.rememberFailure(error) } : {}),
+            audit: (decision) => this.audit(decision),
+        });
+    }
+    async remember(workspaceRoot, request) {
+        await this.host.runtime.workspaceSettings.rememberAllow(workspaceRoot, permissionRuleForRequest(request.toolName, request.input));
+    }
+    async audit(decision) {
+        this.host.runtime.logger.info('Tool authorization decision.', {
+            toolName: decision.toolName,
+            decision: decision.decision,
+            reason: decision.reason,
+            ...(decision.source === undefined ? {} : { source: decision.source }),
+            ...(decision.skillName === undefined ? {} : { skillName: decision.skillName }),
+        });
+        const sessionId = this.host.getSessionId();
+        if (sessionId === undefined)
+            return;
+        await this.host.runtime.sessionStore.appendEvent({
+            type: 'tool.approval',
+            timestamp: new Date().toISOString(),
+            sessionId,
+            data: { toolName: decision.toolName, ...(decision.source === undefined ? {} : { source: decision.source }), ...(decision.skillName === undefined ? {} : { skillName: decision.skillName }), decision: decision.decision, reason: decision.reason },
+        });
+    }
+    rememberFailure(error) {
+        this.host.runtime.logger.warn('Unable to persist tool approval.', { reason: error instanceof Error ? error.message : String(error) });
+        this.host.renderer.notice('Approval accepted for this action, but could not be remembered.');
+    }
+}
+function describeToolApproval(request) {
+    if (request.toolName === 'filesystem.write')
+        return `Write workspace file: ${safeApprovalValue(request.input['path'])}`;
+    if (request.toolName === 'shell.exec') {
+        const command = typeof request.input['command'] === 'string' ? request.input['command'] : '';
+        const args = Array.isArray(request.input['args']) ? request.input['args'].filter((value) => typeof value === 'string') : [];
+        return truncateApprovalDetail(`Run command: ${formatShellCommandForDisplay(command, args, 240)}`);
+    }
+    return `This ${formatToolActivityName(request.toolName)} operation may change workspace or external state.`;
+}
+function safeApprovalValue(value) {
+    const text = typeof value === 'string' ? value : String(value ?? '');
+    return truncateApprovalDetail(text.replace(/Bearer\s+[^\s]+/giu, 'Bearer [REDACTED]').replace(/sk-[A-Za-z0-9_-]{8,}/gu, '[REDACTED]'));
+}
+function truncateApprovalDetail(value) { return value.length <= 240 ? value : `${value.slice(0, 237)}...`; }

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const CLI_VERSION = "0.1.22";

package/dist/version.js

@@ -0,0 +1 @@
+export const CLI_VERSION = '0.1.22';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lotagate/cli",
-  "version": "0.1.20",
+  "version": "0.1.22",
   "description": "Enterprise-grade terminal client for LotaGate AI agents.",
   "type": "module",
   "license": "MIT",
@@ -62,19 +62,20 @@
     "prepack": "npm run build"
   },
   "dependencies": {
-    "@lotagate/agent-sdk": "^0.1.4",
+    "@lotagate/agent-sdk": "^0.1.5",
+    "@lotagate/cli": "^0.1.6",
     "@lotagate/sdk": "^0.1.2",
     "ink": "^7.1.1",
     "react": "^19.2.4",
     "tiktoken": "^1.0.22"
   },
   "optionalDependencies": {
-    "@lotagate/cli-native-linux-arm64-gnu": "0.1.20",
-    "@lotagate/cli-native-linux-x64-gnu": "0.1.20",
-    "@lotagate/cli-native-macos-arm64": "0.1.20",
-    "@lotagate/cli-native-macos-x64": "0.1.20",
-    "@lotagate/cli-native-windows-arm64": "0.1.20",
-    "@lotagate/cli-native-windows-x64": "0.1.20"
+    "@lotagate/cli-native-linux-arm64-gnu": "0.1.22",
+    "@lotagate/cli-native-linux-x64-gnu": "0.1.22",
+    "@lotagate/cli-native-macos-arm64": "0.1.22",
+    "@lotagate/cli-native-macos-x64": "0.1.22",
+    "@lotagate/cli-native-windows-arm64": "0.1.22",
+    "@lotagate/cli-native-windows-x64": "0.1.22"
   },
   "devDependencies": {
     "@eslint/js": "9.39.5",

package/scripts/install-native.mjs

@@ -13,17 +13,17 @@ if (existsSync(resolve(packageRoot, '.git'))) process.exit(0);
 if (target === undefined) await installNodeFallback();
 else await installNativeTarget(target);
 
-function findInstalledNativePackageRoot(packageName) {
-  const segments = packageName.split('/');
-  for (let current = packageRoot; ; current = dirname(current)) {
-    const candidate = resolve(current, 'node_modules', ...segments);
-    if (existsSync(resolve(candidate, 'package.json'))) return candidate;
-    const parent = dirname(current);
-    if (parent === current) break;
-  }
-  return resolve(packageRoot, 'node_modules', ...segments);
-}
-
+function findInstalledNativePackageRoot(packageName) {
+  const segments = packageName.split('/');
+  for (let current = packageRoot; ; current = dirname(current)) {
+    const candidate = resolve(current, 'node_modules', ...segments);
+    if (existsSync(resolve(candidate, 'package.json'))) return candidate;
+    const parent = dirname(current);
+    if (parent === current) break;
+  }
+  return resolve(packageRoot, 'node_modules', ...segments);
+}
+
 async function installNativeTarget(nativeTarget) {
   const nativePackageRoot = findInstalledNativePackageRoot(nativeTarget.packageName);
   const source = resolve(nativePackageRoot, 'bin', nativeTarget.binaryName);