@vybestack/llxprt-code-tools 0.10.0-nightly.260613.1adad3b34

package/dist/src/interfaces/IShellToolHost.d.ts

@@ -0,0 +1,176 @@
+/**
+ * @plan:PLAN-20260608-ISSUE1585.P11
+ * @requirement:REQ-INTERFACE-OWNERSHIP
+ */
+/**
+ * @license
+ * Copyright 2025 Vybestack LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Tools-owned interface for shell tool host dependencies.
+ *
+ * Encapsulates all behaviors that shell tool needs from core
+ * (command policy, path validation, shell execution, output limiting,
+ * summarization, debug mode, timeout settings, etc.) behind a single
+ * adapter interface.
+ *
+ * Consumed by: shell tool in packages/tools.
+ * Implemented by: CoreShellToolHostAdapter in packages/core.
+ */
+/** Result of a shell execution with full metadata. */
+export interface ShellExecutionResult {
+    /** Standard output and error combined. */
+    output: string;
+    /** Process exit code, null if terminated by signal. */
+    exitCode: number | null;
+    /** Signal that terminated the process, null for normal exit. */
+    signal: string | null;
+    /** Error from spawning the process. */
+    error: Error | null;
+    /** Whether the command was aborted. */
+    aborted: boolean;
+    /** Process ID of the spawned process. */
+    pid: number | undefined;
+    /** Background process IDs discovered for non-Windows shells. */
+    backgroundPIDs?: number[];
+    /** Process group ID discovered for non-Windows shells. */
+    pgid?: number | null;
+}
+/** Result of command policy check. */
+export interface CommandPolicyResult {
+    /** Whether the command is allowed. */
+    allowed: boolean;
+    /** Reason for denial if not allowed. */
+    reason?: string;
+}
+/** Output limits configuration. */
+export interface OutputLimits {
+    /** Maximum output tokens, undefined for no limit. */
+    maxTokens?: number;
+    /** Truncation mode. */
+    truncateMode?: string;
+    /** Token limit for summarization. */
+    effectiveTokenLimit?: number;
+}
+/** Shell execution configuration from host. */
+export interface ShellExecutionConfig {
+    /** Whether to use node-pty for shell execution. */
+    shouldUseNodePty: boolean;
+    /** Shell execution options. */
+    executionOptions: Record<string, unknown>;
+    /** PTY terminal width. */
+    ptyTerminalWidth?: number;
+    /** PTY terminal height. */
+    ptyTerminalHeight?: number;
+}
+/** Timeout configuration resolved from settings. */
+export interface ShellTimeoutConfig {
+    /** Resolved timeout in seconds, undefined for no timeout. */
+    timeoutSeconds: number | undefined;
+    /** Default timeout in seconds. */
+    defaultTimeoutSeconds: number;
+}
+/** Command roots extraction result. */
+export interface CommandRootsResult {
+    /** The root commands extracted. */
+    roots: string[];
+}
+export interface IShellToolHost {
+    /**
+     * Get the target/working directory.
+     */
+    getTargetDir(): string;
+    /**
+     * Get the workspace context for path validation.
+     */
+    getWorkspaceContext(): {
+        getDirectories(): string[];
+        isPathWithinWorkspace(resolvedPath: string): boolean;
+    };
+    /**
+     * Check if a command is allowed by policy.
+     */
+    isCommandAllowed(command: string): CommandPolicyResult;
+    /**
+     * Check if a shell invocation is allowlisted (non-interactive mode).
+     */
+    isShellInvocationAllowlisted(command: string, toolName: string): boolean;
+    /**
+     * Check if the environment is interactive.
+     */
+    isInteractive(): boolean;
+    /**
+     * Check if approval mode is YOLO.
+     */
+    isYoloMode(): boolean;
+    /**
+     * Get debug mode status.
+     */
+    getDebugMode(): boolean;
+    /**
+     * Get shell execution configuration.
+     */
+    getShellExecutionConfig(): ShellExecutionConfig;
+    /**
+     * Get timeout configuration for shell commands.
+     */
+    getTimeoutConfig(): ShellTimeoutConfig;
+    /**
+     * Get output limits for shell tool.
+     */
+    getOutputLimits(): OutputLimits;
+    /**
+     * Execute a shell command.
+     */
+    executeShellCommand(command: string, cwd: string, onOutput: (event: ShellOutputEvent) => void, signal: AbortSignal): Promise<ShellExecutionResult>;
+    /**
+     * Get the command roots for a command string.
+     */
+    getCommandRoots(command: string): string[];
+    /**
+     * Strip shell wrapper from a command.
+     */
+    stripShellWrapper(command: string): string;
+    /**
+     * Validate a path is within workspace.
+     */
+    validatePathWithinWorkspace(workspaceContext: {
+        getDirectories(): string[];
+        isPathWithinWorkspace(resolvedPath: string): boolean;
+    }, dirPath: string, label: string): string | null;
+    /**
+     * Check if a PTY PID is active.
+     */
+    isPtyActive(pid: number): boolean;
+    /**
+     * Format memory usage for display.
+     */
+    formatMemoryUsage(bytes: number): string;
+    /**
+     * Try to summarize tool output if summarization is configured.
+     * @returns Summarized output or original content.
+     */
+    trySummarizeOutput(content: string, signal: AbortSignal, tokenBudget?: number): Promise<string>;
+    /**
+     * Get summarize tool output config for shell tool.
+     */
+    getSummarizeConfig(): {
+        tokenBudget?: number;
+    } | undefined;
+    /**
+     * Apply output token limiting.
+     */
+    limitOutputTokens(content: string): {
+        content: string;
+        wasTruncated: boolean;
+    };
+}
+/**
+ * Shell output event from the execution service.
+ */
+export interface ShellOutputEvent {
+    type: 'data' | 'binary_detected' | 'binary_progress';
+    chunk?: string;
+    bytesReceived?: number;
+}

package/dist/src/interfaces/IShellToolHost.js

@@ -0,0 +1,6 @@
+/**
+ * @plan:PLAN-20260608-ISSUE1585.P11
+ * @requirement:REQ-INTERFACE-OWNERSHIP
+ */
+export {};
+//# sourceMappingURL=IShellToolHost.js.map

package/dist/src/interfaces/IShellToolHost.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IShellToolHost.js","sourceRoot":"","sources":["../../../src/interfaces/IShellToolHost.ts"],"names":[],"mappings":"AAAA;;;GAGG"}

package/dist/src/interfaces/ISkillService.d.ts

@@ -0,0 +1,69 @@
+/**
+ * @plan:PLAN-20260608-ISSUE1585.P03
+ * @requirement:REQ-INTERFACE-OWNERSHIP
+ */
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/** Result of a skill activation request. */
+export interface SkillActivationResult {
+    /** Whether the activation succeeded. */
+    success: boolean;
+    /** The activated skill instructions, if any. */
+    instructions?: string;
+    /** Skill description. */
+    description?: string;
+    /** Skill source location. */
+    location?: string;
+    /** Folder structure for skill resources. */
+    folderStructure?: string;
+    /** Directory added to workspace context for skill resources. */
+    resourceDirectory?: string;
+    /** Error message if activation failed. */
+    error?: string;
+    /** Available skill names when activation fails because the skill is missing. */
+    availableSkills?: string[];
+}
+export interface SkillInfo {
+    name: string;
+    description?: string;
+    location?: string;
+}
+/** Opaque handle to the skill manager. */
+export interface SkillManager {
+    /** Discover available skills. */
+    discoverSkills?: (...args: unknown[]) => Promise<void>;
+    /** Get list of skills. */
+    getSkills?: () => SkillInfo[];
+    /** Get one skill by name. */
+    getSkill?: (name: string) => SkillInfo | null;
+    /** Set disabled skills. */
+    setDisabledSkills?: (names: string[]) => void;
+}
+export interface ISkillService {
+    /**
+     * Activate a skill by name.
+     * @param name - The skill name to activate.
+     * @returns The activation result.
+     */
+    activateSkill(name: string): Promise<SkillActivationResult>;
+    /**
+     * Get the skill manager instance.
+     * @returns The skill manager.
+     */
+    getSkillManager(): SkillManager;
+    /**
+     * List available skills for schema generation and validation.
+     */
+    listSkills(): SkillInfo[];
+    /**
+     * Get one skill by name.
+     */
+    getSkill(name: string): SkillInfo | null;
+    /**
+     * Get the folder structure for a skill's resource directory.
+     */
+    getFolderStructure(skillName: string): Promise<string>;
+}

package/dist/src/interfaces/ISkillService.js

@@ -0,0 +1,6 @@
+/**
+ * @plan:PLAN-20260608-ISSUE1585.P03
+ * @requirement:REQ-INTERFACE-OWNERSHIP
+ */
+export {};
+//# sourceMappingURL=ISkillService.js.map

package/dist/src/interfaces/ISkillService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ISkillService.js","sourceRoot":"","sources":["../../../src/interfaces/ISkillService.ts"],"names":[],"mappings":"AAAA;;;GAGG"}

package/dist/src/interfaces/IStorageService.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @plan:PLAN-20260608-ISSUE1585.P03
+ * @requirement:REQ-INTERFACE-OWNERSHIP
+ */
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Tools-owned interface for storage operations.
+ *
+ * Provides LLXPRT directory access and file read/write/ensureDir
+ * needed by the memory tool.
+ *
+ * Consumed by: memoryTool.
+ * Implemented by: CoreStorageServiceAdapter in packages/core.
+ */
+export interface IStorageService {
+    /**
+     * Get the path to the LLXPRT directory.
+     * @returns The LLXPRT directory path.
+     */
+    getLLXPRTDir(): string;
+    /**
+     * Read a file's content as a string.
+     * @param path - The file path to read.
+     * @returns The file content.
+     */
+    readFile(path: string): Promise<string>;
+    /**
+     * Write content to a file.
+     * @param path - The file path to write.
+     * @param content - The content to write.
+     */
+    writeFile(path: string, content: string): Promise<void>;
+    /**
+     * Ensure a directory exists, creating it if necessary.
+     * @param path - The directory path to ensure.
+     */
+    ensureDir(path: string): Promise<void>;
+}

package/dist/src/interfaces/IStorageService.js

@@ -0,0 +1,6 @@
+/**
+ * @plan:PLAN-20260608-ISSUE1585.P03
+ * @requirement:REQ-INTERFACE-OWNERSHIP
+ */
+export {};
+//# sourceMappingURL=IStorageService.js.map

package/dist/src/interfaces/IStorageService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IStorageService.js","sourceRoot":"","sources":["../../../src/interfaces/IStorageService.ts"],"names":[],"mappings":"AAAA;;;GAGG"}

package/dist/src/interfaces/ISubagentService.d.ts

@@ -0,0 +1,112 @@
+/**
+ * @plan:PLAN-20260608-ISSUE1585.P03
+ * @requirement:REQ-INTERFACE-OWNERSHIP
+ */
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { ToolErrorType } from '../types/tool-error.js';
+/** Request to execute a subagent. */
+export interface SubagentRequest {
+    /** Name of the subagent to execute. */
+    name: string;
+    /** Prompt or instruction for the subagent. */
+    prompt: string;
+    /** Optional working directory. */
+    cwd?: string;
+    /** Additional behavioural prompts to append after the primary prompt. */
+    behaviourPrompts?: string[];
+    /** American-spelling alias for behaviourPrompts. */
+    behaviorPrompts?: string[];
+    /** Optional tool whitelist for the subagent runtime. */
+    toolWhitelist?: string[];
+    /** Whether the request included an explicit whitelist even if it was empty. */
+    hasExplicitToolWhitelist?: boolean;
+    /** Expected variables the subagent should emit. */
+    outputSpec?: Record<string, unknown>;
+    /** Optional execution timeout in seconds. */
+    timeoutSeconds?: number;
+    /** Whether the caller requested background execution. */
+    async?: boolean;
+    /** Extra key/value context exposed to the subagent. */
+    context?: Record<string, unknown>;
+}
+/** Runtime options supplied by the Task tool invocation. */
+export interface SubagentExecutionOptions {
+    /** Signal used to cancel foreground execution. */
+    signal?: AbortSignal;
+    /** Optional streaming callback for subagent progress output. */
+    updateOutput?: (output: string) => void;
+}
+/** Result of a subagent execution. */
+export interface SubagentResult {
+    /** The output text from the subagent. */
+    output: string;
+    /** Whether the execution succeeded. */
+    success: boolean;
+    /** Error message if execution failed. */
+    error?: string;
+    /** Runtime agent id when execution launched. */
+    agentId?: string;
+    /** Termination reason from the subagent runtime. */
+    terminateReason?: string;
+    /** Variables emitted by the subagent runtime. */
+    emittedVars?: Record<string, unknown>;
+    /** Exact LLM content when the service owns legacy-compatible formatting. */
+    llmContent?: string;
+    /** Exact return display when the service owns legacy-compatible formatting. */
+    returnDisplay?: string;
+    /** Tool metadata produced by the service. */
+    metadata?: Record<string, unknown>;
+    /** Specific tool error type for failures. */
+    errorType?: ToolErrorType;
+}
+/** Information about a discovered subagent. */
+export interface SubagentInfo {
+    /** Name of the subagent. */
+    name: string;
+    /** Description of the subagent. */
+    description?: string;
+    /** Associated profile name. */
+    profile?: string;
+    /** Last update timestamp. */
+    updatedAt?: string;
+}
+/** Configuration for a subagent. */
+export interface SubagentConfig {
+    /** Name of the subagent. */
+    name: string;
+    /** Instructions or system prompt for the subagent. */
+    instructions?: string;
+    /** System prompt for the subagent. */
+    systemPrompt?: string;
+    /** The model to use. */
+    model?: string;
+    /** Associated profile name. */
+    profile?: string;
+    /** Last update timestamp. */
+    updatedAt?: string;
+    /** Additional configuration properties. */
+    [key: string]: unknown;
+}
+export interface ISubagentService {
+    /**
+     * Execute a subagent with the given request.
+     * @param request - The subagent execution request.
+     * @returns The execution result.
+     */
+    executeSubagent(request: SubagentRequest, options?: SubagentExecutionOptions): Promise<SubagentResult>;
+    /**
+     * List all available subagents.
+     * @returns Array of subagent information.
+     */
+    listSubagents(): Promise<SubagentInfo[]>;
+    /**
+     * Get configuration for a specific subagent.
+     * @param name - The subagent name.
+     * @returns The subagent configuration, or undefined if not found.
+     */
+    getSubagentConfig(name: string): Promise<SubagentConfig | undefined>;
+}

package/dist/src/interfaces/ISubagentService.js

@@ -0,0 +1,6 @@
+/**
+ * @plan:PLAN-20260608-ISSUE1585.P03
+ * @requirement:REQ-INTERFACE-OWNERSHIP
+ */
+export {};
+//# sourceMappingURL=ISubagentService.js.map

package/dist/src/interfaces/ISubagentService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ISubagentService.js","sourceRoot":"","sources":["../../../src/interfaces/ISubagentService.ts"],"names":[],"mappings":"AAAA;;;GAGG"}

package/dist/src/interfaces/ITaskToolHost.d.ts

@@ -0,0 +1,185 @@
+/**
+ * @plan:PLAN-20260608-ISSUE1585.P11
+ * @requirement:REQ-INTERFACE-OWNERSHIP
+ */
+/**
+ * @license
+ * Copyright 2025 Vybestack LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Tools-owned interface for task tool host dependencies.
+ *
+ * Encapsulates all behaviors that task tool needs from core
+ * (orchestration, governance, async tasks, scheduler, tool registry,
+ * settings, timeout) behind adapter interfaces.
+ *
+ * Historical task-host contract retained for compatibility with earlier P11 plans.
+ * Current task execution uses ISubagentService, implemented by
+ * CoreSubagentServiceAdapter in packages/core.
+ */
+/** Information about a launched subagent. */
+export interface LaunchedSubagent {
+    /** Unique agent identifier. */
+    agentId: string;
+    /** The subagent scope for interaction. */
+    scope: ISubagentScope;
+    /** Cleanup function. */
+    dispose: () => Promise<void>;
+}
+/** Subagent scope interface for interaction. */
+export interface ISubagentScope {
+    /** Output from subagent execution. */
+    output: ISubagentOutput | undefined;
+    /** Message handler for streaming. */
+    onMessage: ((message: string) => void) | undefined;
+    /** Run the subagent interactively. */
+    runInteractive(contextState: unknown, options?: {
+        schedulerFactory?: unknown;
+    }): Promise<void>;
+    /** Run the subagent non-interactively. */
+    runNonInteractive(contextState: unknown): Promise<void>;
+    /** Cancel the subagent. */
+    cancel?(reason?: string): void;
+}
+/** Output from subagent execution. */
+export interface ISubagentOutput {
+    /** Reason for termination. */
+    terminate_reason: string;
+    /** Emitted variables from the subagent. */
+    emitted_vars: Record<string, unknown>;
+    /** Final message from the subagent. */
+    final_message?: string;
+}
+/** Launch request for a subagent. */
+export interface TaskLaunchRequest {
+    /** Name of the subagent. */
+    name: string;
+    /** Run configuration. */
+    runConfig?: {
+        max_time_minutes?: number;
+    };
+    /** Behaviour prompts. */
+    behaviourPrompts?: string[];
+    /** Tool configuration. */
+    toolConfig?: {
+        tools: string[];
+    };
+    /** Output configuration. */
+    outputConfig?: {
+        outputs: Record<string, string>;
+    };
+}
+/** Timeout configuration for task execution. */
+export interface TaskTimeoutConfig {
+    /** Resolved timeout in seconds, undefined for no timeout. */
+    timeoutSeconds: number | undefined;
+    /** Default timeout in seconds. */
+    defaultTimeoutSeconds: number;
+}
+/** Result of async settings check. */
+export interface AsyncSettingsCheck {
+    /** Whether async is enabled. */
+    enabled: boolean;
+    /** Reason if disabled. */
+    reason?: string;
+}
+/** Async slot reservation result. */
+export interface AsyncSlotResult {
+    /** Reservation ID if slot was obtained. */
+    bookingId: string | undefined;
+}
+/** Async task registration input. */
+export interface AsyncTaskRegistration {
+    id: string;
+    subagentName: string;
+    goalPrompt: string;
+    abortController: AbortController;
+}
+/** Can-launch result for async tasks. */
+export interface CanLaunchResult {
+    /** Whether an async task can be launched. */
+    reason?: string;
+}
+/** Governs tool access for the subagent. */
+export interface IToolGovernance {
+    /** Whether the given tool name is blocked. */
+    isToolBlocked(canonicalName: string): boolean;
+}
+export interface ITaskToolHost {
+    /**
+     * Launch a subagent with the given request.
+     */
+    launchSubagent(request: TaskLaunchRequest, signal?: AbortSignal): Promise<LaunchedSubagent>;
+    /**
+     * Check if the environment is interactive.
+     */
+    isInteractiveEnvironment(): boolean;
+    /**
+     * Get the interactive subagent scheduler factory, if available.
+     */
+    getSchedulerFactory(): unknown | undefined;
+    /**
+     * Get timeout configuration for task execution.
+     */
+    getTimeoutConfig(requestedTimeoutSeconds: number | undefined): TaskTimeoutConfig;
+    /**
+     * Get async timeout configuration.
+     */
+    getAsyncTimeoutConfig(requestedTimeoutSeconds: number | undefined): TaskTimeoutConfig;
+    /**
+     * Check if async tasks are enabled in settings.
+     */
+    checkAsyncSettings(): AsyncSettingsCheck;
+    /**
+     * Check if async task manager is available.
+     */
+    hasAsyncTaskManager(): boolean;
+    /**
+     * Try to reserve an async slot.
+     */
+    tryReserveAsyncSlot(): string | undefined;
+    /**
+     * Register an async task.
+     */
+    registerAsyncTask(task: AsyncTaskRegistration, bookingId: string | undefined): void;
+    /**
+     * Cancel an async slot reservation.
+     */
+    cancelAsyncReservation(bookingId: string): void;
+    /**
+     * Check if an async task can be launched.
+     */
+    canLaunchAsync(): CanLaunchResult;
+    /**
+     * Get the session ID.
+     */
+    getSessionId(): string;
+    /**
+     * Build governed tool whitelist from candidates and registry.
+     * Returns filtered list of tools that are allowed by governance.
+     */
+    buildGovernedToolWhitelist(candidateTools: string[] | undefined, hasExplicitWhitelist: boolean): string[] | undefined;
+    /**
+     * Get the default agent ID.
+     */
+    getDefaultAgentId(): string;
+    /**
+     * Complete an async task.
+     */
+    completeAsyncTask(agentId: string, output: ISubagentOutput): void;
+    /**
+     * Fail an async task.
+     */
+    failAsyncTask(agentId: string, error: string): void;
+    /**
+     * Get an async task by ID.
+     */
+    getAsyncTask(agentId: string): {
+        status: string;
+    } | undefined;
+    /**
+     * Cancel async reservation on error.
+     */
+    cancelAsyncTaskReservation(bookingId: string | undefined, taskRegistered: boolean): void;
+}

package/dist/src/interfaces/ITaskToolHost.js

@@ -0,0 +1,6 @@
+/**
+ * @plan:PLAN-20260608-ISSUE1585.P11
+ * @requirement:REQ-INTERFACE-OWNERSHIP
+ */
+export {};
+//# sourceMappingURL=ITaskToolHost.js.map

package/dist/src/interfaces/ITaskToolHost.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ITaskToolHost.js","sourceRoot":"","sources":["../../../src/interfaces/ITaskToolHost.ts"],"names":[],"mappings":"AAAA;;;GAGG"}