aman-intelligence 0.1.0

package/dist/services/environment.service.js

@@ -0,0 +1,227 @@
+import { execFileSync, spawnSync } from 'child_process';
+import os from 'os';
+import path from 'path';
+import { GLOBAL_CONFIG_DIR, GLOBAL_DIR, LOCAL_DIR } from '../config/paths.js';
+import { configService } from './config.service.js';
+import { copyDir, ensureDir, exists, writeJson } from '../storage/filesystem.js';
+const ENVIRONMENT_DIRS = ['skills', 'prompts', 'mcps', 'stacks'];
+function expandHome(inputPath) {
+    if (inputPath === '~')
+        return os.homedir();
+    if (inputPath.startsWith(`~${path.sep}`) || inputPath.startsWith('~/')) {
+        return path.join(os.homedir(), inputPath.slice(2));
+    }
+    return inputPath;
+}
+function repoSlugToDirName(repository) {
+    return repository.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'aman-environment';
+}
+export class EnvironmentService {
+    getActiveEnvironmentDir() {
+        return configService.get('environmentPath') || GLOBAL_DIR;
+    }
+    getStorage() {
+        return configService.get('storage') || { type: 'local' };
+    }
+    getProjectEnvironmentDir() {
+        return path.resolve(process.cwd(), LOCAL_DIR);
+    }
+    isEnvironmentInitialized(scope = 'global') {
+        const base = scope === 'project' ? this.getProjectEnvironmentDir() : this.getActiveEnvironmentDir();
+        return exists(path.join(base, 'aman.json'));
+    }
+    resolveStoragePath(storagePath) {
+        return path.resolve(expandHome(storagePath || GLOBAL_DIR));
+    }
+    isGithubCliAvailable() {
+        try {
+            this.addKnownGithubCliPaths();
+            execFileSync('gh', ['--version'], { stdio: 'ignore' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    installGithubCli() {
+        if (this.isGithubCliAvailable())
+            return;
+        const attempts = this.githubCliInstallAttempts();
+        if (attempts.length === 0) {
+            throw new Error('Automatic GitHub CLI install is not supported on this operating system yet.');
+        }
+        for (const attempt of attempts) {
+            const result = spawnSync(attempt.command, attempt.args, { stdio: 'pipe' });
+            if (result.status === 0 && this.isGithubCliAvailable()) {
+                return;
+            }
+        }
+        throw new Error('Could not install GitHub CLI automatically.');
+    }
+    async ensureEnvironment(baseDir, storage) {
+        await ensureDir(baseDir);
+        for (const dir of ENVIRONMENT_DIRS) {
+            await ensureDir(path.join(baseDir, dir));
+        }
+        const manifestPath = path.join(baseDir, 'aman.json');
+        if (!exists(manifestPath)) {
+            const manifest = {
+                name: path.basename(baseDir) || 'aman-environment',
+                version: 1,
+                createdAt: new Date().toISOString(),
+                storage,
+            };
+            await writeJson(manifestPath, manifest);
+        }
+    }
+    async ensureProjectEnvironment() {
+        const projectDir = this.getProjectEnvironmentDir();
+        await this.ensureEnvironment(projectDir, { type: 'local' });
+        return projectDir;
+    }
+    async ensureActiveEnvironment() {
+        const environmentPath = this.getActiveEnvironmentDir();
+        await this.ensureEnvironment(environmentPath, this.getStorage());
+        return environmentPath;
+    }
+    async initLocal(options = {}) {
+        const environmentPath = this.resolveStoragePath(options.storagePath);
+        await this.ensureEnvironment(environmentPath, { type: 'local' });
+        await ensureDir(GLOBAL_CONFIG_DIR);
+        configService.set('environmentPath', environmentPath);
+        configService.set('storage', { type: 'local' });
+        return environmentPath;
+    }
+    async initGithub(options) {
+        this.ensureGhAvailable();
+        this.ensureGhAuthenticated();
+        const repoDir = path.join(GLOBAL_DIR, 'repositories', repoSlugToDirName(options.repository));
+        await ensureDir(path.dirname(repoDir));
+        if (options.mode === 'existing') {
+            await this.cloneRepository(options.repository, repoDir);
+            await this.ensureEnvironment(repoDir, { type: 'github', repository: options.repository });
+            this.gitCommitAndPush(repoDir, 'Standardize Aman environment');
+        }
+        else {
+            await this.ensureEnvironment(repoDir, { type: 'github', repository: options.repository });
+            this.gitInit(repoDir);
+            this.gitCommit(repoDir, 'Initial Aman environment');
+            this.createAndPushRepository(options.repository, repoDir);
+        }
+        await ensureDir(GLOBAL_CONFIG_DIR);
+        configService.set('environmentPath', repoDir);
+        configService.set('storage', { type: 'github', repository: options.repository });
+        return repoDir;
+    }
+    async importStandardized(sourceDir, targetDir) {
+        await this.ensureEnvironment(targetDir, { type: 'local' });
+        for (const dir of ENVIRONMENT_DIRS) {
+            const src = path.join(sourceDir, dir);
+            if (exists(src)) {
+                await copyDir(src, path.join(targetDir, dir));
+            }
+        }
+    }
+    ensureGhAvailable() {
+        if (!this.isGithubCliAvailable()) {
+            throw new Error('GitHub CLI not found.');
+        }
+    }
+    addKnownGithubCliPaths() {
+        if (process.platform !== 'win32')
+            return;
+        const pathKey = Object.keys(process.env).find((key) => key.toLowerCase() === 'path') || 'Path';
+        const currentPath = process.env[pathKey] || '';
+        const candidates = [
+            process.env.ProgramFiles ? path.join(process.env.ProgramFiles, 'GitHub CLI') : undefined,
+            process.env['ProgramFiles(x86)'] ? path.join(process.env['ProgramFiles(x86)'], 'GitHub CLI') : undefined,
+            process.env.LOCALAPPDATA ? path.join(process.env.LOCALAPPDATA, 'GitHub CLI') : undefined,
+        ].filter((candidate) => Boolean(candidate));
+        for (const candidate of candidates) {
+            if (!exists(path.join(candidate, 'gh.exe')))
+                continue;
+            if (currentPath.toLowerCase().split(';').includes(candidate.toLowerCase()))
+                continue;
+            process.env[pathKey] = `${candidate};${currentPath}`;
+            return;
+        }
+    }
+    githubCliInstallAttempts() {
+        if (process.platform === 'win32') {
+            return [
+                {
+                    command: 'winget',
+                    args: [
+                        'install',
+                        '--id',
+                        'GitHub.cli',
+                        '-e',
+                        '--source',
+                        'winget',
+                        '--accept-package-agreements',
+                        '--accept-source-agreements',
+                    ],
+                },
+                { command: 'choco', args: ['install', 'gh', '-y'] },
+                { command: 'scoop', args: ['install', 'gh'] },
+            ];
+        }
+        if (process.platform === 'darwin') {
+            return [{ command: 'brew', args: ['install', 'gh'] }];
+        }
+        if (process.platform === 'linux') {
+            return [
+                { command: 'sh', args: ['-lc', 'command -v apt-get >/dev/null && sudo apt-get update && sudo apt-get install -y gh'] },
+                { command: 'sh', args: ['-lc', 'command -v dnf >/dev/null && sudo dnf install -y gh'] },
+                { command: 'sh', args: ['-lc', 'command -v yum >/dev/null && sudo yum install -y gh'] },
+                { command: 'sh', args: ['-lc', 'command -v pacman >/dev/null && sudo pacman -S --noconfirm github-cli'] },
+            ];
+        }
+        return [];
+    }
+    ensureGhAuthenticated() {
+        const status = spawnSync('gh', ['auth', 'status'], { stdio: 'ignore' });
+        if (status.status === 0)
+            return;
+        const login = spawnSync('gh', ['auth', 'login'], { stdio: 'inherit' });
+        if (login.status !== 0) {
+            throw new Error('GitHub authentication was not completed.');
+        }
+    }
+    cloneRepository(repository, repoDir) {
+        if (exists(repoDir))
+            return;
+        const result = spawnSync('gh', ['repo', 'clone', repository, repoDir], { stdio: 'pipe' });
+        if (result.status !== 0) {
+            const errDetail = result.stderr?.toString().trim();
+            throw new Error(`Could not clone ${repository}. Check the repository name and your GitHub access.${errDetail ? ` Details: ${errDetail}` : ''}`);
+        }
+    }
+    gitInit(repoDir) {
+        if (exists(path.join(repoDir, '.git')))
+            return;
+        execFileSync('git', ['-C', repoDir, 'init'], { stdio: 'ignore' });
+    }
+    gitCommit(repoDir, message) {
+        execFileSync('git', ['-C', repoDir, 'add', '.'], { stdio: 'ignore' });
+        execFileSync('git', ['-C', repoDir, 'commit', '-m', message], { stdio: 'ignore' });
+    }
+    gitCommitAndPush(repoDir, message) {
+        try {
+            execFileSync('git', ['-C', repoDir, 'add', '.'], { stdio: 'ignore' });
+            execFileSync('git', ['-C', repoDir, 'diff', '--cached', '--quiet'], { stdio: 'ignore' });
+        }
+        catch {
+            this.gitCommit(repoDir, message);
+            execFileSync('git', ['-C', repoDir, 'push'], { stdio: 'ignore' });
+        }
+    }
+    createAndPushRepository(repository, repoDir) {
+        const result = spawnSync('gh', ['repo', 'create', repository, '--private', '--source', repoDir, '--remote', 'origin', '--push'], { stdio: 'pipe' });
+        if (result.status !== 0) {
+            const errDetail = result.stderr?.toString().trim();
+            throw new Error(`Could not create GitHub repository ${repository}.${errDetail ? ` Details: ${errDetail}` : ''}`);
+        }
+    }
+}
+export const environmentService = new EnvironmentService();

package/dist/services/github.service.d.ts

@@ -0,0 +1,7 @@
+export declare class GithubService {
+    /**
+     * Imports a repository from GitHub or a local folder to a temporary directory.
+     */
+    import(source: string): Promise<string>;
+}
+export declare const githubService: GithubService;

package/dist/services/github.service.js

@@ -0,0 +1,42 @@
+import { spawnSync } from 'child_process';
+import { exists, ensureDir, removeDir } from '../storage/filesystem.js';
+import path from 'path';
+import os from 'os';
+export class GithubService {
+    /**
+     * Imports a repository from GitHub or a local folder to a temporary directory.
+     */
+    async import(source) {
+        const tempDir = path.join(os.tmpdir(), `aman-import-${Date.now()}`);
+        await ensureDir(tempDir);
+        let cloneUrl = source;
+        // Handle local folder
+        if (source.startsWith('.') || path.isAbsolute(source) || exists(source)) {
+            const srcPath = path.resolve(process.cwd(), source);
+            if (!exists(srcPath)) {
+                throw new Error(`Local path does not exist: ${srcPath}`);
+            }
+            const { copyDir } = await import('../storage/filesystem.js');
+            await copyDir(srcPath, tempDir);
+            return tempDir;
+        }
+        // Handle user/repo format
+        if (!source.startsWith('http') && source.includes('/')) {
+            cloneUrl = `https://github.com/${source}.git`;
+        }
+        try {
+            const result = spawnSync('git', ['clone', '--depth', '1', cloneUrl, tempDir], { stdio: 'ignore' });
+            if (result.status !== 0) {
+                throw new Error('clone failed');
+            }
+            // Remove .git directory so it's not detected as part of the assets
+            await removeDir(path.join(tempDir, '.git'));
+            return tempDir;
+        }
+        catch {
+            await removeDir(tempDir);
+            throw new Error(`Failed to clone ${cloneUrl}. Is git installed? Does the repo exist?`);
+        }
+    }
+}
+export const githubService = new GithubService();

package/dist/services/lock.service.d.ts

@@ -0,0 +1,12 @@
+import { Lockfile, LockEntry, AssetType, Scope } from '../types/index.js';
+export declare class LockService {
+    private getLockfilePath;
+    private scopeRoot;
+    read(scope: Scope): Promise<Lockfile>;
+    private quarantineCorruptFile;
+    write(scope: Scope, lockfile: Lockfile): Promise<void>;
+    getEntries(lockfile: Lockfile): LockEntry[];
+    addEntry(scope: Scope, entry: LockEntry): Promise<void>;
+    removeEntry(scope: Scope, localName: string, type: AssetType): Promise<void>;
+}
+export declare const lockService: LockService;

package/dist/services/lock.service.js

@@ -0,0 +1,71 @@
+import path from 'path';
+import { LOCAL_LOCKFILE } from '../config/paths.js';
+import { exists, readJson, writeJson } from '../storage/filesystem.js';
+import { promises as fs } from 'fs';
+import { environmentService } from './environment.service.js';
+import { isLegacyLockfile, normalizeLockfile } from '../utils/lock-migrate.js';
+import { migrateScopeLayout } from '../storage/asset-layout.js';
+import { LOCAL_DIR } from '../config/paths.js';
+export class LockService {
+    async getLockfilePath(scope) {
+        return scope === 'global' ? path.join(environmentService.getActiveEnvironmentDir(), 'aman.lock') : LOCAL_LOCKFILE;
+    }
+    scopeRoot(scope) {
+        return scope === 'global' ? environmentService.getActiveEnvironmentDir() : LOCAL_DIR;
+    }
+    async read(scope) {
+        const lockPath = await this.getLockfilePath(scope);
+        await migrateScopeLayout(this.scopeRoot(scope));
+        let raw = await readJson(lockPath);
+        if (raw === null && exists(lockPath)) {
+            await this.quarantineCorruptFile(lockPath, 'lock');
+            raw = null;
+        }
+        const lockfile = normalizeLockfile(raw, scope);
+        if (raw && isLegacyLockfile(raw)) {
+            await writeJson(lockPath, lockfile);
+        }
+        return lockfile;
+    }
+    async quarantineCorruptFile(filePath, label) {
+        const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const backupPath = `${filePath}.corrupt-${stamp}`;
+        try {
+            await fs.rename(filePath, backupPath);
+            console.warn(`  Warning: Corrupt ${label} file quarantined to ${backupPath}`);
+        }
+        catch {
+            // If rename fails, leave file in place; normalizeLockfile still returns empty
+        }
+    }
+    async write(scope, lockfile) {
+        await migrateScopeLayout(this.scopeRoot(scope));
+        const lockPath = await this.getLockfilePath(scope);
+        await writeJson(lockPath, {
+            ...lockfile,
+            schemaVersion: 1,
+            scope,
+            generatedAt: new Date().toISOString(),
+        });
+    }
+    getEntries(lockfile) {
+        return lockfile.assets;
+    }
+    async addEntry(scope, entry) {
+        const lockfile = await this.read(scope);
+        const existingIndex = lockfile.assets.findIndex((e) => e.type === entry.type && e.localName === entry.localName);
+        if (existingIndex >= 0) {
+            lockfile.assets[existingIndex] = { ...entry, scope };
+        }
+        else {
+            lockfile.assets.push({ ...entry, scope });
+        }
+        await this.write(scope, lockfile);
+    }
+    async removeEntry(scope, localName, type) {
+        const lockfile = await this.read(scope);
+        lockfile.assets = lockfile.assets.filter((e) => !(e.type === type && e.localName === localName));
+        await this.write(scope, lockfile);
+    }
+}
+export const lockService = new LockService();

package/dist/services/marketplace.service.d.ts

@@ -0,0 +1,40 @@
+import { AssetType, ProviderResult } from '../types/index.js';
+import { MarketplaceAsset, MarketplaceSearchResult } from '../marketplace/types.js';
+export interface InstallCandidate {
+    name: string;
+    type: AssetType;
+    source: string;
+    sources?: string[];
+    sourcePath: string;
+    description?: string;
+    tags?: string[];
+    category?: string;
+    installs?: number;
+    rating?: number;
+    updated?: string;
+    version?: string;
+    organization?: string;
+    installed?: boolean;
+    slug?: string;
+    checksum?: string;
+    verified?: boolean;
+    githubSource?: string;
+    marketplaceAsset?: MarketplaceAsset;
+}
+export declare class MarketplaceService {
+    private providers;
+    listProviders(): string[];
+    search(query: string, type?: AssetType): Promise<ProviderResult[]>;
+    searchGitHubMarketplace(_query: string, _type?: AssetType): Promise<MarketplaceSearchResult>;
+    loadGitHubMarketplaceCatalog(options?: {
+        query?: string;
+        typeFilter?: 'all' | AssetType;
+    }): Promise<MarketplaceSearchResult>;
+    private marketplaceAssetToResult;
+    findInstallCandidate(name: string): Promise<InstallCandidate | null>;
+    private mergeResults;
+    private normalizeName;
+    private uniqueSources;
+    private uniqueTags;
+}
+export declare const marketplaceService: MarketplaceService;

package/dist/services/marketplace.service.js

@@ -0,0 +1,225 @@
+import { skillsShProvider } from '../providers/skills-sh.provider.js';
+import { localProvider } from '../providers/local.provider.js';
+import { registryProvider } from '../providers/registry.provider.js';
+import { ASSET_TAB_ORDER } from '../ui/assetDisplay.js';
+import { findMarketplaceAsset, indexMarketplaceAssets, loadMarketplaceIndex, searchGitHubMarketplace, } from '../marketplace/github-search.js';
+import { MARKETPLACE_ENABLED } from '../config/features.js';
+const EMPTY_MARKETPLACE_RESULT = {
+    assets: [],
+    fromCache: false,
+    cacheAgeMinutes: null,
+    rateLimited: false,
+    offline: false,
+};
+export class MarketplaceService {
+    providers = [registryProvider, skillsShProvider, localProvider];
+    listProviders() {
+        return this.providers.map((provider) => provider.name);
+    }
+    async search(query, type) {
+        const localResults = [];
+        for (const provider of this.providers) {
+            if (!(await provider.available()))
+                continue;
+            const results = await provider.search(query, type);
+            for (const r of results) {
+                localResults.push({ ...r, section: 'local' });
+            }
+        }
+        const mergedLocal = this.mergeResults(localResults);
+        if (!MARKETPLACE_ENABLED) {
+            return mergedLocal;
+        }
+        const gh = await searchGitHubMarketplace({
+            query,
+            typeFilter: type ?? 'all',
+        });
+        indexMarketplaceAssets(gh.assets);
+        let marketplace = gh.assets.map((a) => this.marketplaceAssetToResult(a));
+        if (type) {
+            marketplace = marketplace.filter((r) => r.type === type);
+        }
+        return [...mergedLocal, ...marketplace];
+    }
+    async searchGitHubMarketplace(_query, _type) {
+        if (!MARKETPLACE_ENABLED)
+            return { ...EMPTY_MARKETPLACE_RESULT };
+        return searchGitHubMarketplace({ query: _query, typeFilter: _type ?? 'all' });
+    }
+    async loadGitHubMarketplaceCatalog(options) {
+        if (!MARKETPLACE_ENABLED)
+            return { ...EMPTY_MARKETPLACE_RESULT };
+        return loadMarketplaceIndex({
+            query: options?.query ?? '',
+            typeFilter: options?.typeFilter ?? 'all',
+        });
+    }
+    marketplaceAssetToResult(asset) {
+        return {
+            type: asset.type,
+            name: asset.localName,
+            slug: asset.slug,
+            source: 'Marketplace',
+            sources: ['marketplace'],
+            description: asset.description,
+            tags: asset.tags,
+            version: asset.version,
+            organization: asset.author,
+            stars: asset.stars,
+            verified: asset.verified,
+            section: 'marketplace',
+            checksum: asset.checksum,
+            githubSource: asset.source,
+            confidence: 0.95,
+            installed: false,
+        };
+    }
+    async findInstallCandidate(name) {
+        const trimmed = name.trim();
+        if (MARKETPLACE_ENABLED && trimmed.startsWith('@')) {
+            await loadMarketplaceIndex({ query: '' });
+            const gh = findMarketplaceAsset(trimmed);
+            if (gh) {
+                return {
+                    name: gh.localName,
+                    type: gh.type,
+                    source: 'marketplace',
+                    sources: ['marketplace'],
+                    sourcePath: '',
+                    description: gh.description,
+                    tags: gh.tags,
+                    version: gh.version,
+                    organization: gh.author,
+                    slug: gh.slug,
+                    checksum: gh.checksum,
+                    verified: gh.verified,
+                    githubSource: gh.source,
+                    marketplaceAsset: gh,
+                };
+            }
+        }
+        const types = ASSET_TAB_ORDER;
+        const requestedName = this.normalizeName(name);
+        for (const type of types) {
+            const mergedMatches = await this.search(name, type);
+            const exact = mergedMatches.find((item) => this.normalizeName(item.name) === requestedName);
+            if (!exact)
+                continue;
+            for (const provider of this.providers) {
+                if (!(await provider.available()))
+                    continue;
+                const providerMatches = await provider.search(exact.name, type);
+                const providerExact = providerMatches.find((item) => this.normalizeName(item.name) === this.normalizeName(exact.name));
+                if (!providerExact)
+                    continue;
+                if (exact.section === 'marketplace') {
+                    await loadMarketplaceIndex({ query: '' });
+                    const gh = findMarketplaceAsset(exact.slug ?? exact.name) ??
+                        findMarketplaceAsset(exact.name);
+                    if (gh) {
+                        return {
+                            name: gh.localName,
+                            type: gh.type,
+                            source: 'marketplace',
+                            sources: ['marketplace'],
+                            sourcePath: '',
+                            description: gh.description,
+                            tags: gh.tags,
+                            version: gh.version,
+                            organization: gh.author,
+                            slug: gh.slug,
+                            checksum: gh.checksum,
+                            verified: gh.verified,
+                            githubSource: gh.source,
+                            marketplaceAsset: gh,
+                        };
+                    }
+                }
+                return {
+                    name: exact.name,
+                    type: exact.type,
+                    source: provider.name,
+                    sources: exact.sources,
+                    sourcePath: await provider.fetch(exact.name, exact.type),
+                    description: exact.description,
+                    tags: exact.tags,
+                    category: exact.category,
+                    installs: exact.installs,
+                    rating: exact.rating,
+                    updated: exact.updated,
+                    version: exact.version,
+                    organization: exact.organization,
+                    installed: exact.installed,
+                    slug: exact.slug,
+                    checksum: exact.checksum,
+                    verified: exact.verified,
+                    githubSource: exact.githubSource,
+                };
+            }
+        }
+        return null;
+    }
+    mergeResults(results) {
+        const merged = new Map();
+        for (const result of results) {
+            const key = `${result.type}:${this.normalizeName(result.name)}`;
+            const existing = merged.get(key);
+            if (!existing) {
+                const sources = this.uniqueSources(result.sources || [result.source]);
+                merged.set(key, {
+                    ...result,
+                    sources,
+                    source: sources.join(' + '),
+                    tags: this.uniqueTags(result.tags),
+                    installed: Boolean(result.installed || sources.includes('installed')),
+                });
+                continue;
+            }
+            const sources = this.uniqueSources([
+                ...(existing.sources || [existing.source]),
+                ...(result.sources || [result.source]),
+            ]);
+            merged.set(key, {
+                ...existing,
+                source: sources.join(' + '),
+                sources,
+                description: existing.description || result.description,
+                tags: this.uniqueTags([...(existing.tags || []), ...(result.tags || [])]),
+                category: existing.category || result.category,
+                installs: existing.installs ?? result.installs,
+                rating: existing.rating ?? result.rating,
+                updated: existing.updated || result.updated,
+                version: existing.version || result.version,
+                organization: existing.organization || result.organization,
+                installed: Boolean(existing.installed || result.installed || sources.includes('installed')),
+                confidence: Math.max(existing.confidence, result.confidence),
+            });
+        }
+        return Array.from(merged.values()).sort((a, b) => a.name.localeCompare(b.name));
+    }
+    normalizeName(value) {
+        return value.trim().toLowerCase().replace(/[\s_]+/g, '-');
+    }
+    uniqueSources(sources) {
+        const priority = ['installed', 'registry', 'skills.sh', 'bundled', 'local'];
+        const unique = Array.from(new Set(sources.filter(Boolean)));
+        return unique.sort((a, b) => {
+            const aIndex = priority.indexOf(a);
+            const bIndex = priority.indexOf(b);
+            if (aIndex === -1 && bIndex === -1)
+                return a.localeCompare(b);
+            if (aIndex === -1)
+                return 1;
+            if (bIndex === -1)
+                return -1;
+            return aIndex - bIndex;
+        });
+    }
+    uniqueTags(tags) {
+        if (!tags)
+            return undefined;
+        const unique = Array.from(new Set(tags.filter((tag) => tag.trim().length > 0)));
+        return unique.length > 0 ? unique : undefined;
+    }
+}
+export const marketplaceService = new MarketplaceService();

package/dist/services/pack.service.d.ts

@@ -0,0 +1,9 @@
+import { Pack, Scope } from '../types/index.js';
+export declare class PackService {
+    create(name: string, packData: Pack, outputPath: string): Promise<void>;
+    install(packPath: string, scope: Scope, onProgress?: (progress: number) => void): Promise<void>;
+    inspect(packPath: string): Promise<Pack>;
+    private walk;
+    private extractPack;
+}
+export declare const packService: PackService;