@lotagate/cli 0.1.22 → 0.1.24

package/dist/infrastructure/extensions/mcp-runtime.js

@@ -1,52 +0,0 @@
-import { McpClientManager } from '@lotagate/agent-sdk';
-import { CliError } from '../../domain/errors/cli-error.js';
-import { CLI_ERROR_CODES } from '../../domain/errors/error-codes.js';
-import { FileMcpConfigStore } from './file-mcp-config-store.js';
-export class McpRuntime {
-    storeFactory;
-    manager;
-    constructor(storeFactory = (cwd) => new FileMcpConfigStore(cwd)) {
-        this.storeFactory = storeFactory;
-    }
-    async connectConfigured(cwd, trusted) {
-        if (!trusted)
-            throw new CliError(CLI_ERROR_CODES.PROJECT_TRUST_REQUIRED, 'MCP connections require project trust.', { category: 'project', userMessage: 'Trust the project before connecting to MCP servers.' });
-        const configured = await this.storeFactory(cwd).list();
-        const servers = toAgentMcpConfig(configured);
-        await this.close();
-        // Reconnect and transport policy remain owned by Agent SDK so all CLI entry
-        // points use the same lifecycle semantics.
-        this.manager = new McpClientManager(servers);
-        return this.manager.connectAll();
-    }
-    get client() { return this.manager; }
-    async close() {
-        const manager = this.manager;
-        this.manager = undefined;
-        if (manager !== undefined)
-            await manager.disconnectAll();
-    }
-}
-export function toAgentMcpConfig(config) {
-    const result = {};
-    for (const [name, entry] of Object.entries(config)) {
-        if (!entry.enabled)
-            continue;
-        result[name] = cloneMcpServerConfig(entry.config);
-    }
-    return result;
-}
-function cloneMcpServerConfig(config) {
-    if (config.type === 'stdio') {
-        return {
-            ...config,
-            ...(config.args === undefined ? {} : { args: [...config.args] }),
-            ...(config.env === undefined ? {} : { env: { ...config.env } }),
-        };
-    }
-    return {
-        ...config,
-        ...(config.headers === undefined ? {} : { headers: { ...config.headers } }),
-        ...(config.auth?.type === 'bearer' ? { auth: { ...config.auth } } : {}),
-    };
-}

package/dist/infrastructure/extensions/plugin-discovery.d.ts

@@ -1,5 +0,0 @@
-import { type PluginManifest } from '../../domain/extensions/plugin-manifest.js';
-export declare class PluginDiscovery {
-    discover(roots: readonly string[]): Promise<readonly PluginManifest[]>;
-}
-export declare function validatePluginManifest(manifest: PluginManifest): Promise<void>;

package/dist/infrastructure/extensions/plugin-discovery.js

@@ -1,52 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { parsePluginManifest } from '../../domain/extensions/plugin-manifest.js';
-import { CliError } from '../../domain/errors/cli-error.js';
-import { CLI_ERROR_CODES } from '../../domain/errors/error-codes.js';
-import { isFileNotFound } from '../filesystem/fs-errors.js';
-import { readJsonFileBounded } from '../filesystem/bounded-json-reader.js';
-import { RESOURCE_LIMITS } from '../../domain/runtime/resource-limits.js';
-import { listExtensionDirectories } from './extension-directory-reader.js';
-export class PluginDiscovery {
-    async discover(roots) {
-        const plugins = [];
-        for (const root of roots) {
-            for (const directory of await listExtensionDirectories(root)) {
-                const manifestPath = path.join(directory, '.lotagate-plugin', 'plugin.json');
-                try {
-                    const manifest = parsePluginManifest(await readJsonFileBounded(manifestPath, RESOURCE_LIMITS.pluginManifestBytes), directory);
-                    await validatePluginManifest(manifest);
-                    plugins.push(manifest);
-                }
-                catch (error) {
-                    if (!isFileNotFound(error))
-                        throw error;
-                }
-            }
-        }
-        return plugins.sort((left, right) => left.name.localeCompare(right.name));
-    }
-}
-export async function validatePluginManifest(manifest) {
-    const pluginRoot = await fs.realpath(manifest.directory);
-    for (const relative of [manifest.skillsDirectory, manifest.agentsDirectory, manifest.hooksDirectory, manifest.mcpConfig]) {
-        if (relative === undefined)
-            continue;
-        if (path.isAbsolute(relative) || relative.split(/[\\/]/u).includes('..'))
-            throw new CliError(CLI_ERROR_CODES.PLUGIN_MANIFEST_INVALID, `Plugin path escapes plugin directory: ${relative}`, { category: 'extension', userMessage: 'Plugin manifest contains a path outside the plugin directory.' });
-        const candidate = path.resolve(pluginRoot, relative);
-        try {
-            const stat = await fs.lstat(candidate);
-            if (stat.isSymbolicLink())
-                throw new Error('symbolic-link');
-            const canonical = await fs.realpath(candidate);
-            if (canonical !== pluginRoot && !canonical.startsWith(`${pluginRoot}${path.sep}`))
-                throw new Error('outside-root');
-        }
-        catch (error) {
-            if (isFileNotFound(error))
-                continue;
-            throw new CliError(CLI_ERROR_CODES.PLUGIN_MANIFEST_INVALID, `Plugin path is not contained in the plugin directory: ${relative}`, { category: 'extension', userMessage: 'Plugin manifest contains an unsafe path.', cause: error });
-        }
-    }
-}

package/dist/infrastructure/extensions/plugin-manager.d.ts

@@ -1,26 +0,0 @@
-import { type PluginManifest } from '../../domain/extensions/plugin-manifest.js';
-export interface InstalledPlugin {
-    manifest: PluginManifest;
-    enabled: boolean;
-    integrity?: string;
-}
-export interface PluginInstallOptions {
-    sha256?: string;
-    signature?: string;
-    publicKeyPem?: string;
-}
-export interface PluginListOptions {
-    verifyIntegrity?: boolean;
-}
-export declare class PluginManager {
-    private readonly root;
-    private readonly statePath;
-    constructor(root: string);
-    list(roots?: readonly string[], options?: PluginListOptions): Promise<readonly InstalledPlugin[]>;
-    install(source: string, options?: PluginInstallOptions): Promise<InstalledPlugin>;
-    uninstall(name: string): Promise<boolean>;
-    setEnabled(name: string, enabled: boolean): Promise<void>;
-    private readState;
-    private writeState;
-}
-export declare function hashDirectory(directory: string): Promise<string>;

package/dist/infrastructure/extensions/plugin-manager.js

@@ -1,139 +0,0 @@
-import crypto from 'node:crypto';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { parsePluginManifest } from '../../domain/extensions/plugin-manifest.js';
-import { CliError } from '../../domain/errors/cli-error.js';
-import { CLI_ERROR_CODES } from '../../domain/errors/error-codes.js';
-import { PluginDiscovery, validatePluginManifest } from './plugin-discovery.js';
-import { atomicWriteFile, withFileLock } from '../filesystem/atomic-file-store.js';
-import { isAlreadyExists, isFileNotFound } from '../filesystem/fs-errors.js';
-import { readJsonFileBounded } from '../filesystem/bounded-json-reader.js';
-import { RESOURCE_LIMITS } from '../../domain/runtime/resource-limits.js';
-import { parseExtensionState } from '../../domain/extensions/extension-state.js';
-export class PluginManager {
-    root;
-    statePath;
-    constructor(root) {
-        this.root = root;
-        this.statePath = path.join(root, 'state.json');
-    }
-    async list(roots = [this.root], options = {}) {
-        const state = await this.readState();
-        const discovered = await new PluginDiscovery().discover(roots);
-        const plugins = [];
-        for (const manifest of discovered) {
-            const integrity = options.verifyIntegrity === false ? undefined : await hashDirectory(manifest.directory);
-            plugins.push({ manifest, enabled: state[manifest.name]?.enabled !== false, ...(integrity === undefined ? {} : { integrity }) });
-        }
-        return plugins;
-    }
-    async install(source, options = {}) {
-        const sourceDirectory = path.resolve(source);
-        const manifestPath = path.join(sourceDirectory, '.lotagate-plugin', 'plugin.json');
-        const manifest = parsePluginManifest(await readJsonFileBounded(manifestPath, RESOURCE_LIMITS.pluginManifestBytes), sourceDirectory);
-        await validatePluginManifest(manifest);
-        const integrity = await hashDirectory(sourceDirectory);
-        if (options.sha256 !== undefined && normalizeDigest(options.sha256) !== integrity)
-            throw invalidInstall('Plugin checksum does not match --sha256.');
-        if (options.signature !== undefined || options.publicKeyPem !== undefined) {
-            if (options.signature === undefined || options.publicKeyPem === undefined)
-                throw invalidInstall('Signature verification requires both --signature and --public-key.');
-            const verified = crypto.verify(null, Buffer.from(integrity, 'utf8'), options.publicKeyPem, Buffer.from(options.signature, 'base64'));
-            if (!verified)
-                throw invalidInstall('Plugin signature verification failed.');
-        }
-        await fs.mkdir(this.root, { recursive: true });
-        const destination = path.join(this.root, safePluginDirectoryName(manifest.name));
-        const temporary = `${destination}.tmp-${crypto.randomUUID()}`;
-        try {
-            await fs.cp(sourceDirectory, temporary, { recursive: true, force: false, errorOnExist: true });
-            await validatePluginManifest({ ...manifest, directory: temporary });
-            const temporaryIntegrity = await hashDirectory(temporary);
-            if (temporaryIntegrity !== integrity)
-                throw invalidInstall('Plugin changed while it was being installed.');
-            await fs.rename(temporary, destination).catch(async (error) => {
-                if (!isAlreadyExists(error))
-                    throw error;
-                await fs.rm(destination, { recursive: true, force: true });
-                await fs.rename(temporary, destination);
-            });
-            await this.setEnabled(manifest.name, true);
-            return { manifest: { ...manifest, directory: destination }, enabled: true, integrity: temporaryIntegrity };
-        }
-        finally {
-            await fs.rm(temporary, { recursive: true, force: true });
-        }
-    }
-    async uninstall(name) {
-        const plugin = (await this.list([this.root], { verifyIntegrity: false })).find((item) => item.manifest.name === name);
-        if (plugin === undefined)
-            return false;
-        await fs.rm(plugin.manifest.directory, { recursive: true, force: true });
-        await withFileLock(this.statePath, async () => { const state = await this.readState(); delete state[name]; await this.writeState(state); });
-        return true;
-    }
-    async setEnabled(name, enabled) {
-        await withFileLock(this.statePath, async () => {
-            const state = await this.readState();
-            state[name] = { enabled };
-            await this.writeState(state);
-        });
-    }
-    async readState() {
-        try {
-            return parseExtensionState(await readJsonFileBounded(this.statePath, RESOURCE_LIMITS.workspaceSettingsBytes));
-        }
-        catch (error) {
-            if (isFileNotFound(error))
-                return {};
-            throw error;
-        }
-    }
-    async writeState(state) {
-        await atomicWriteFile(this.statePath, `${JSON.stringify(state, null, 2)}\n`);
-    }
-}
-export async function hashDirectory(directory) {
-    const hash = crypto.createHash('sha256');
-    let totalBytes = 0;
-    for (const file of await filesRecursively(directory)) {
-        const relative = path.relative(directory, file).split(path.sep).join('/');
-        const stat = await fs.stat(file);
-        if (stat.size > MAX_PLUGIN_FILE_BYTES)
-            throw invalidInstall('Plugin file exceeds the integrity scan limit.');
-        totalBytes += stat.size;
-        if (totalBytes > MAX_PLUGIN_TOTAL_BYTES)
-            throw invalidInstall('Plugin exceeds the total integrity scan limit.');
-        hash.update(relative);
-        hash.update('\0');
-        hash.update(await fs.readFile(file));
-        hash.update('\0');
-    }
-    return hash.digest('hex');
-}
-const MAX_PLUGIN_FILES = 5_000;
-const MAX_PLUGIN_FILE_BYTES = 10 * 1024 * 1024;
-const MAX_PLUGIN_TOTAL_BYTES = 50 * 1024 * 1024;
-const MAX_PLUGIN_DEPTH = 32;
-async function filesRecursively(directory, depth = 0, state = { files: 0 }) {
-    if (depth > MAX_PLUGIN_DEPTH)
-        throw invalidInstall('Plugin directory nesting exceeds the integrity scan limit.');
-    const result = [];
-    for (const entry of (await fs.readdir(directory, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) {
-        const file = path.join(directory, entry.name);
-        if (entry.isSymbolicLink())
-            throw invalidInstall('Plugin packages must not contain symbolic links.');
-        if (entry.isDirectory())
-            result.push(...await filesRecursively(file, depth + 1, state));
-        else if (entry.isFile()) {
-            result.push(file);
-            state.files += 1;
-            if (state.files > MAX_PLUGIN_FILES)
-                throw invalidInstall('Plugin contains too many files for the integrity scan.');
-        }
-    }
-    return result;
-}
-function safePluginDirectoryName(name) { return `plugin-${Buffer.from(name, 'utf8').toString('base64url')}`; }
-function normalizeDigest(value) { return value.trim().toLowerCase().replace(/^sha256[:-]/u, ''); }
-function invalidInstall(message) { return new CliError(CLI_ERROR_CODES.PLUGIN_MANIFEST_INVALID, message, { category: 'extension', userMessage: `Unable to install plugin: ${message}` }); }

package/dist/infrastructure/extensions/skill-discovery.d.ts

@@ -1,4 +0,0 @@
-import { type SkillManifest } from '../../domain/extensions/skill-manifest.js';
-export declare class SkillDiscovery {
-    discover(roots: readonly string[]): Promise<readonly SkillManifest[]>;
-}

package/dist/infrastructure/extensions/skill-discovery.js

@@ -1,29 +0,0 @@
-import path from 'node:path';
-import { parseSkillDocument } from '../../domain/extensions/skill-manifest.js';
-import { isFileNotFound } from '../filesystem/fs-errors.js';
-import { readFileBounded } from '../filesystem/bounded-file-reader.js';
-import { RESOURCE_LIMITS } from '../../domain/runtime/resource-limits.js';
-import { listExtensionDirectories } from './extension-directory-reader.js';
-export class SkillDiscovery {
-    async discover(roots) {
-        const skills = new Map();
-        for (const root of roots) {
-            for (const directory of await listExtensionDirectories(root)) {
-                const skillFile = path.join(directory, 'SKILL.md');
-                try {
-                    const content = await readFileBounded(skillFile, RESOURCE_LIMITS.skillDocumentBytes);
-                    if (content.truncated)
-                        throw new Error('Skill document exceeds the supported size.');
-                    const skill = parseSkillDocument(content.bytes.toString('utf8'), directory);
-                    if (!skills.has(skill.name))
-                        skills.set(skill.name, skill);
-                }
-                catch (error) {
-                    if (!isFileNotFound(error))
-                        throw error;
-                }
-            }
-        }
-        return [...skills.values()].sort((left, right) => left.name.localeCompare(right.name));
-    }
-}

package/dist/infrastructure/extensions/skill-installer.d.ts

@@ -1,8 +0,0 @@
-import { type SkillManifest } from '../../domain/extensions/skill-manifest.js';
-export interface InstalledSkill {
-    manifest: SkillManifest;
-    integrity: string;
-}
-export declare class SkillInstaller {
-    install(source: string, root: string): Promise<InstalledSkill | undefined>;
-}

package/dist/infrastructure/extensions/skill-installer.js

@@ -1,88 +0,0 @@
-import fs from 'node:fs/promises';
-import crypto from 'node:crypto';
-import path from 'node:path';
-import { parseSkillDocument } from '../../domain/extensions/skill-manifest.js';
-import { CliError } from '../../domain/errors/cli-error.js';
-import { CLI_ERROR_CODES } from '../../domain/errors/error-codes.js';
-import { hashDirectory } from './plugin-manager.js';
-import { isFileNotFound } from '../filesystem/fs-errors.js';
-import { readFileBounded } from '../filesystem/bounded-file-reader.js';
-import { RESOURCE_LIMITS } from '../../domain/runtime/resource-limits.js';
-export class SkillInstaller {
-    async install(source, root) {
-        if (await hasPluginManifest(source))
-            return undefined;
-        const sourceDirectory = await resolveSkillDirectory(path.resolve(source));
-        if (sourceDirectory === undefined)
-            return undefined;
-        const skillFile = await readFileBounded(path.join(sourceDirectory, 'SKILL.md'), RESOURCE_LIMITS.skillDocumentBytes);
-        if (skillFile.truncated)
-            throw invalidSkillSource('Skill document exceeds the supported size.');
-        const manifest = parseSkillDocument(skillFile.bytes.toString('utf8'), sourceDirectory);
-        const sourceIntegrity = await hashDirectory(sourceDirectory);
-        await fs.mkdir(root, { recursive: true });
-        const destination = path.join(root, manifest.name);
-        const temporary = `${destination}.tmp-${crypto.randomUUID()}`;
-        try {
-            await fs.cp(sourceDirectory, temporary, { recursive: true, force: false, errorOnExist: true });
-            const temporaryIntegrity = await hashDirectory(temporary);
-            if (temporaryIntegrity !== sourceIntegrity)
-                throw new Error('Skill changed while it was being installed.');
-            await fs.rm(destination, { recursive: true, force: true });
-            await fs.rename(temporary, destination);
-            return { manifest: { ...manifest, directory: destination }, integrity: temporaryIntegrity };
-        }
-        finally {
-            await fs.rm(temporary, { recursive: true, force: true });
-        }
-    }
-}
-async function hasPluginManifest(source) {
-    try {
-        const stat = await fs.stat(path.join(source, '.lotagate-plugin', 'plugin.json'));
-        return stat.isFile();
-    }
-    catch (error) {
-        if (!isFileNotFound(error))
-            throw error;
-        return false;
-    }
-}
-async function resolveSkillDirectory(source) {
-    try {
-        const stat = await fs.stat(path.join(source, 'SKILL.md'));
-        if (stat.isFile())
-            return source;
-    }
-    catch (error) {
-        if (!isFileNotFound(error))
-            throw error;
-    }
-    let entries;
-    try {
-        entries = await fs.readdir(source, { withFileTypes: true });
-    }
-    catch (error) {
-        if (isFileNotFound(error))
-            return undefined;
-        throw error;
-    }
-    const candidates = [];
-    for (const entry of entries.filter((item) => item.isDirectory())) {
-        try {
-            const stat = await fs.stat(path.join(source, entry.name, 'SKILL.md'));
-            if (stat.isFile())
-                candidates.push(path.join(source, entry.name));
-        }
-        catch (error) {
-            if (!isFileNotFound(error))
-                throw error;
-        }
-    }
-    if (candidates.length > 1)
-        throw invalidSkillSource('Source contains multiple skills. Pass the individual skill directory.');
-    return candidates[0];
-}
-function invalidSkillSource(message) {
-    return new CliError(CLI_ERROR_CODES.SKILL_FRONTMATTER_INVALID, message, { category: 'extension', userMessage: `Unable to install skill: ${message}` });
-}

package/dist/infrastructure/extensions/skill-manager.d.ts

@@ -1,22 +0,0 @@
-import type { SkillManifest } from '../../domain/extensions/skill-manifest.js';
-import type { SkillRootScope } from './skill-roots.js';
-export type ScopedSkill = SkillManifest & {
-    skillKey: string;
-    enabled: boolean;
-    scope: SkillRootScope['scope'];
-    root: string;
-    statePath: string;
-    pluginName?: string;
-};
-export interface ScopedSkillListOptions {
-    includeShadowed?: boolean;
-}
-export declare class SkillManager {
-    private readonly statePath;
-    constructor(statePath: string);
-    listScoped(scopes: readonly SkillRootScope[], options?: ScopedSkillListOptions): Promise<readonly ScopedSkill[]>;
-    setEnabled(name: string, enabled: boolean, statePath?: string): Promise<void>;
-    remove(name: string, root: string, statePath?: string): Promise<boolean>;
-    private readState;
-    private writeState;
-}

package/dist/infrastructure/extensions/skill-manager.js

@@ -1,67 +0,0 @@
-import fs from 'node:fs/promises';
-import { SkillDiscovery } from './skill-discovery.js';
-import { atomicWriteFile, withFileLock } from '../filesystem/atomic-file-store.js';
-import { isFileNotFound } from '../filesystem/fs-errors.js';
-import { readJsonFileBounded } from '../filesystem/bounded-json-reader.js';
-import { RESOURCE_LIMITS } from '../../domain/runtime/resource-limits.js';
-import { parseExtensionState } from '../../domain/extensions/extension-state.js';
-export class SkillManager {
-    statePath;
-    constructor(statePath) {
-        this.statePath = statePath;
-    }
-    async listScoped(scopes, options = {}) {
-        const states = new Map();
-        const result = [];
-        const claimedNames = new Set();
-        const pluginNames = new Set();
-        for (const scope of scopes) {
-            if (!states.has(scope.statePath))
-                states.set(scope.statePath, await this.readState(scope.statePath));
-            const state = states.get(scope.statePath);
-            for (const skill of await new SkillDiscovery().discover([scope.root])) {
-                const isPlugin = scope.scope === 'plugin';
-                const shadowed = claimedNames.has(skill.name) || (!isPlugin && scope.scope === 'builtin' && pluginNames.has(skill.name));
-                if (options.includeShadowed !== true && shadowed)
-                    continue;
-                if (isPlugin)
-                    pluginNames.add(skill.name);
-                else if (scope.scope !== 'builtin')
-                    claimedNames.add(skill.name);
-                const skillKey = isPlugin ? `${scope.pluginName ?? 'plugin'}:${skill.name}` : skill.name;
-                result.push({ ...skill, skillKey, enabled: state[skillKey]?.enabled !== false, scope: scope.scope, root: scope.root, statePath: scope.statePath, ...(scope.pluginName === undefined ? {} : { pluginName: scope.pluginName }) });
-            }
-        }
-        return result;
-    }
-    async setEnabled(name, enabled, statePath = this.statePath) {
-        await withFileLock(statePath, async () => {
-            const state = await this.readState(statePath);
-            state[name] = { enabled };
-            await this.writeState(state, statePath);
-        });
-    }
-    async remove(name, root, statePath = this.statePath) {
-        const skill = (await new SkillDiscovery().discover([root])).find((item) => item.name === name || `${item.name}` === name);
-        if (skill === undefined)
-            return false;
-        await fs.rm(skill.directory, { recursive: true, force: true });
-        await withFileLock(statePath, async () => {
-            const state = await this.readState(statePath);
-            delete state[name];
-            await this.writeState(state, statePath);
-        });
-        return true;
-    }
-    async readState(statePath = this.statePath) {
-        try {
-            return parseExtensionState(await readJsonFileBounded(statePath, RESOURCE_LIMITS.workspaceSettingsBytes));
-        }
-        catch (error) {
-            if (isFileNotFound(error))
-                return {};
-            throw error;
-        }
-    }
-    async writeState(state, statePath = this.statePath) { await atomicWriteFile(statePath, `${JSON.stringify(state, null, 2)}\n`); }
-}

package/dist/infrastructure/extensions/skill-roots.d.ts

@@ -1,19 +0,0 @@
-import type { ExtensionScope } from '../../domain/extensions/extension-scope.js';
-export interface SkillRootScope {
-    scope: ExtensionScope | 'plugin' | 'builtin';
-    root: string;
-    statePath: string;
-    pluginName?: string;
-}
-export interface PluginSkillRoot {
-    root: string;
-    pluginName: string;
-}
-/**
- * Returns skill roots in precedence order: project, user, enabled plugins,
- * then immutable package-provided skills. SkillManager keeps project/user
- * definitions authoritative while qualifying plugin identities so independent
- * plugins can expose the same raw skill name safely.
- */
-export declare function resolveSkillRootScopes(cwd: string, globalConfigDir: string, pluginSkillRoots?: readonly PluginSkillRoot[]): readonly SkillRootScope[];
-export declare function builtinSkillsDirectory(executablePath?: string): string;

package/dist/infrastructure/extensions/skill-roots.js

@@ -1,25 +0,0 @@
-import path from 'node:path';
-import { existsSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-/**
- * Returns skill roots in precedence order: project, user, enabled plugins,
- * then immutable package-provided skills. SkillManager keeps project/user
- * definitions authoritative while qualifying plugin identities so independent
- * plugins can expose the same raw skill name safely.
- */
-export function resolveSkillRootScopes(cwd, globalConfigDir, pluginSkillRoots = []) {
-    const projectRoot = path.join(cwd, '.lotagate', 'skills');
-    const userStatePath = path.join(globalConfigDir, 'skills-state.json');
-    return [
-        { scope: 'project', root: projectRoot, statePath: path.join(cwd, '.lotagate', 'skills-state.json') },
-        { scope: 'user', root: path.join(globalConfigDir, 'skills'), statePath: userStatePath },
-        ...pluginSkillRoots.map(({ root, pluginName }) => ({ scope: 'plugin', root, pluginName, statePath: userStatePath })),
-        { scope: 'builtin', root: builtinSkillsDirectory(), statePath: userStatePath },
-    ];
-}
-export function builtinSkillsDirectory(executablePath = process.execPath) {
-    const nativeDistributionSkills = path.resolve(path.dirname(executablePath), '..', 'skills');
-    if (existsSync(nativeDistributionSkills))
-        return nativeDistributionSkills;
-    return fileURLToPath(new URL('../../../skills/', import.meta.url));
-}

package/dist/infrastructure/extensions/skill-tool-executor.d.ts

@@ -1,18 +0,0 @@
-import type { ToolDefinition } from '@lotagate/sdk';
-import type { ToolExecutionContext, ToolExecutor, ToolInfo, ToolResult } from '@lotagate/agent-sdk';
-import type { SkillManifest } from '../../domain/extensions/skill-manifest.js';
-import type { SkillScopeStore } from '../../application/extensions/skill-scope-store.js';
-/** Exposes the same skill capability definitions to runtime and context accounting. */
-export declare function skillToolDefinitions(): readonly ToolDefinition[];
-/** Presents validated, model-invocable skills as lazy agent tools. */
-export declare class SkillToolExecutor implements ToolExecutor {
-    private readonly scopes;
-    private readonly skills;
-    constructor(skills: readonly (SkillManifest & {
-        enabled: boolean;
-        skillKey?: string;
-    })[], scopes: SkillScopeStore);
-    listTools(): readonly ToolDefinition[];
-    getToolInfo(toolName: string): ToolInfo | undefined;
-    execute(toolName: string, input: Record<string, unknown>, context: ToolExecutionContext): Promise<ToolResult>;
-}

package/dist/infrastructure/extensions/skill-tool-executor.js

@@ -1,53 +0,0 @@
-const SKILL_TOOLS = [
-    toolDefinition('skill.list', 'List enabled skills available to the agent.', { type: 'object', properties: {}, additionalProperties: false }),
-    toolDefinition('skill.load', 'Load instructions for one enabled skill by name when its description matches the task.', {
-        type: 'object',
-        properties: { name: { type: 'string', description: 'Enabled skill name.' } },
-        required: ['name'],
-        additionalProperties: false,
-    }),
-];
-/** Exposes the same skill capability definitions to runtime and context accounting. */
-export function skillToolDefinitions() { return SKILL_TOOLS; }
-/** Presents validated, model-invocable skills as lazy agent tools. */
-export class SkillToolExecutor {
-    scopes;
-    skills;
-    constructor(skills, scopes) {
-        this.scopes = scopes;
-        this.skills = skills.filter((skill) => skill.enabled && skill.modelInvocable);
-    }
-    listTools() { return skillToolDefinitions(); }
-    getToolInfo(toolName) {
-        return SKILL_TOOLS.some((tool) => getToolName(tool) === toolName)
-            ? { toolName, source: 'custom', executorId: 'skill-catalog', metadata: { category: 'skill', risk: 'read' } }
-            : undefined;
-    }
-    async execute(toolName, input, context) {
-        if (toolName === 'skill.list') {
-            return result(JSON.stringify(this.skills.map((skill) => ({ name: skill.skillKey ?? skill.name, description: skill.description }))));
-        }
-        if (toolName !== 'skill.load')
-            return error(`Unknown skill tool: ${toolName}`);
-        const name = input['name'];
-        if (typeof name !== 'string')
-            return error('skill.load requires a skill name.');
-        const skill = this.skills.find((candidate) => (candidate.skillKey ?? candidate.name) === name);
-        if (skill === undefined)
-            return error(`Skill is unavailable: ${name}`);
-        this.scopes.activate(context.runId, skill);
-        return result(boundText(skill.body, context.maxResultBytes));
-    }
-}
-function toolDefinition(name, description, parameters) {
-    return { type: 'function', function: { name, description, parameters } };
-}
-function getToolName(tool) {
-    return 'function' in tool ? tool.function.name : undefined;
-}
-function result(content) { return { content, isError: false }; }
-function error(content) { return { content, isError: true }; }
-function boundText(content, maxBytes) {
-    const bytes = Buffer.from(content, 'utf8');
-    return bytes.byteLength <= maxBytes ? content : `${bytes.subarray(0, maxBytes).toString('utf8')}\n[truncated]`;
-}

package/dist/infrastructure/filesystem/atomic-file-store.d.ts

@@ -1,12 +0,0 @@
-import fs from 'node:fs/promises';
-/** Writes a file through a same-directory temporary file and rename. */
-export declare function atomicWriteFile(filePath: string, data: string | Uint8Array, mode?: number): Promise<void>;
-/** Creates an advisory lock and removes it again when lock metadata cannot be persisted. */
-export declare function acquireAdvisoryFileLock(lockPath: string): Promise<fs.FileHandle>;
-/** Closes an advisory lock handle and removes its lock file even when close fails. */
-export declare function releaseAdvisoryFileLock(handle: fs.FileHandle, lockPath: string): Promise<void>;
-/** Serializes mutations across CLI processes using an advisory lock file. */
-export declare function withFileLock<T>(filePath: string, operation: () => Promise<T>, options?: {
-    timeoutMs?: number;
-    staleMs?: number;
-}): Promise<T>;