aman-intelligence 0.1.0

package/dist/import/utils.js

@@ -0,0 +1,428 @@
+import os from 'os';
+import path from 'path';
+import { promises as fs } from 'fs';
+import { exists, readJson, readFrontmatter } from '../storage/filesystem.js';
+import { defaultSlugForName } from '../utils/slug.js';
+import { randomUUID } from 'crypto';
+export function expandHome(inputPath) {
+    if (inputPath === '~')
+        return os.homedir();
+    if (inputPath.startsWith('~/') || inputPath.startsWith(`~${path.sep}`)) {
+        return path.join(os.homedir(), inputPath.slice(2));
+    }
+    return inputPath;
+}
+export function vscodeUserMcpPath() {
+    if (process.platform === 'win32') {
+        return path.join(process.env.APPDATA ?? path.join(os.homedir(), 'AppData', 'Roaming'), 'Code', 'User', 'mcp.json');
+    }
+    if (process.platform === 'darwin') {
+        return path.join(os.homedir(), 'Library', 'Application Support', 'Code', 'User', 'mcp.json');
+    }
+    return path.join(os.homedir(), '.config', 'Code', 'User', 'mcp.json');
+}
+export function slugifyImportName(name) {
+    const base = name
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return base || defaultSlugForName(name);
+}
+export function makeAssetId() {
+    return randomUUID();
+}
+export async function discoverSkillDir(skillDir, adapterId, originLabel) {
+    const skillMd = path.join(skillDir, 'SKILL.md');
+    if (!exists(skillMd))
+        return null;
+    const hasMeta = exists(path.join(skillDir, 'metadata.json'));
+    let description = '';
+    const fm = await readFrontmatter(skillMd);
+    if (fm) {
+        description = (typeof fm.description === 'string' ? fm.description : '') ||
+            (typeof fm.name === 'string' ? fm.name : '');
+    }
+    const name = path.basename(skillDir);
+    return {
+        id: makeAssetId(),
+        type: 'skill',
+        name: slugifyImportName(name),
+        description,
+        sourcePath: skillDir,
+        originLabel,
+        canonicalStatus: hasMeta ? 'canonical' : 'convertible',
+        canonicalNote: hasMeta ? undefined : 'Will generate metadata.json on import',
+        confidence: hasMeta ? 95 : 85,
+        adapterId,
+    };
+}
+export async function discoverPromptFile(filePath, adapterId, originLabel, suggestedName) {
+    const base = suggestedName ?? path.basename(filePath, path.extname(filePath));
+    let description = '';
+    const fm = await readFrontmatter(filePath);
+    if (fm && typeof fm.description === 'string') {
+        description = fm.description;
+    }
+    const canonicalStatus = path.basename(filePath).toUpperCase() === 'PROMPT.MD'
+        ? 'canonical'
+        : 'convertible';
+    return {
+        id: makeAssetId(),
+        type: 'prompt',
+        name: slugifyImportName(base),
+        description,
+        sourcePath: filePath,
+        originLabel,
+        canonicalStatus,
+        canonicalNote: canonicalStatus === 'convertible' ? 'Markdown will be normalized to PROMPT.md layout' : undefined,
+        confidence: canonicalStatus === 'canonical' ? 95 : 75,
+        adapterId,
+    };
+}
+export async function listSkillDirs(root) {
+    if (!exists(root))
+        return [];
+    const { listDirs } = await import('../storage/filesystem.js');
+    const dirs = await listDirs(root);
+    return dirs.map((d) => path.join(root, d)).filter((d) => exists(path.join(d, 'SKILL.md')));
+}
+export function extractMcpServerMap(raw) {
+    if (raw.mcpServers && typeof raw.mcpServers === 'object' && raw.mcpServers !== null) {
+        return raw.mcpServers;
+    }
+    if (raw.servers && typeof raw.servers === 'object' && raw.servers !== null) {
+        return raw.servers;
+    }
+    return {};
+}
+export async function discoverMcpFromJsonFile(filePath, adapterId, originPrefix) {
+    if (!exists(filePath))
+        return [];
+    const raw = await readJson(filePath);
+    if (!raw)
+        return [];
+    const servers = extractMcpServerMap(raw);
+    const results = [];
+    for (const [serverName, config] of Object.entries(servers)) {
+        if (!config || typeof config !== 'object')
+            continue;
+        results.push({
+            id: makeAssetId(),
+            type: 'mcp',
+            name: slugifyImportName(serverName),
+            description: `MCP server "${serverName}" from ${originPrefix}`,
+            sourcePath: filePath,
+            originLabel: `${originPrefix} → ${serverName}`,
+            canonicalStatus: 'convertible',
+            canonicalNote: `Will extract server "${serverName}" into canonical mcp.json`,
+            confidence: 80,
+            adapterId,
+            mcpServerName: serverName,
+        });
+    }
+    return results;
+}
+/** Minimal TOML [mcp_servers.name] block parser for Codex config.toml */
+export function parseCodexMcpBlocks(tomlText) {
+    const blocks = [];
+    const lines = tomlText.split(/\r?\n/);
+    let current = null;
+    for (const line of lines) {
+        const section = line.match(/^\[mcp_servers\.([^\]]+)\]\s*$/);
+        if (section) {
+            if (current)
+                blocks.push({ name: current.name, body: current.body.join('\n') });
+            current = { name: section[1], body: [] };
+            continue;
+        }
+        if (current && line.trim() && !line.startsWith('[')) {
+            current.body.push(line);
+        }
+    }
+    if (current)
+        blocks.push({ name: current.name, body: current.body.join('\n') });
+    return blocks;
+}
+export function codexBlockToMcpJson(block) {
+    const server = {};
+    for (const line of block.body.split('\n')) {
+        const kv = line.match(/^([a-zA-Z0-9_]+)\s*=\s*(.+)$/);
+        if (!kv)
+            continue;
+        const key = kv[1];
+        let val = kv[2].trim();
+        if (typeof val === 'string' && val.startsWith('"') && val.endsWith('"')) {
+            val = val.slice(1, -1);
+        }
+        else if (val === 'true' || val === 'false') {
+            val = val === 'true';
+        }
+        server[key] = val;
+    }
+    if (typeof server.url === 'string') {
+        return {
+            mcpServers: {
+                [block.name]: {
+                    type: 'http',
+                    url: server.url,
+                    ...(typeof server.bearer_token_env_var === 'string'
+                        ? { headers: { Authorization: `Bearer $${server.bearer_token_env_var}` } }
+                        : {}),
+                },
+            },
+        };
+    }
+    const command = typeof server.command === 'string' ? server.command : undefined;
+    const args = Array.isArray(server.args)
+        ? server.args
+        : typeof server.args === 'string'
+            ? [server.args]
+            : [];
+    return {
+        mcpServers: {
+            [block.name]: {
+                ...(command ? { command, args } : {}),
+                ...(server.env && typeof server.env === 'object' ? { env: server.env } : {}),
+            },
+        },
+    };
+}
+/**
+ * Discover rules-style markdown files as skills.
+ * Used by Cursor (.cursor/rules/, .cursorrules) and Windsurf (.windsurf/rules/, .windsurfrules).
+ */
+export async function discoverRulesAsSkills(rulePaths, dotfilePaths, adapterId, originPrefix) {
+    const found = [];
+    const seen = new Set();
+    // Scan directories of rule files
+    for (const rulesDir of rulePaths) {
+        if (!exists(rulesDir))
+            continue;
+        let files;
+        try {
+            files = await fs.readdir(rulesDir);
+        }
+        catch {
+            continue;
+        }
+        for (const file of files) {
+            if (!file.endsWith('.md') && !file.endsWith('.mdc'))
+                continue;
+            const filePath = path.join(rulesDir, file);
+            const key = `skill:${filePath}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            let description = '';
+            const fm = await readFrontmatter(filePath);
+            if (fm && typeof fm.description === 'string') {
+                description = fm.description;
+            }
+            const name = file.replace(/\.(md|mdc)$/, '');
+            found.push({
+                id: makeAssetId(),
+                type: 'skill',
+                name: slugifyImportName(name),
+                description: description || `Rule file from ${adapterId}`,
+                sourcePath: filePath,
+                originLabel: `${originPrefix}/${file}`,
+                canonicalStatus: 'convertible',
+                canonicalNote: 'Rule file will be converted to SKILL.md',
+                confidence: 80,
+                adapterId,
+                provenance: {
+                    tool: adapterId,
+                    sourcePath: filePath,
+                    importedAt: new Date().toISOString(),
+                },
+            });
+        }
+    }
+    // Scan dotfiles (.cursorrules, .windsurfrules)
+    for (const dotfile of dotfilePaths) {
+        if (!exists(dotfile))
+            continue;
+        const key = `skill:${dotfile}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const baseName = path.basename(dotfile).replace(/^\./, '');
+        found.push({
+            id: makeAssetId(),
+            type: 'skill',
+            name: slugifyImportName(baseName),
+            description: `Root rules file from ${adapterId}`,
+            sourcePath: dotfile,
+            originLabel: path.basename(dotfile),
+            canonicalStatus: 'convertible',
+            canonicalNote: 'Dotfile will be converted to SKILL.md',
+            confidence: 75,
+            adapterId,
+            provenance: {
+                tool: adapterId,
+                sourcePath: dotfile,
+                importedAt: new Date().toISOString(),
+            },
+        });
+    }
+    return found;
+}
+/**
+ * Discover Continue.dev prompt files from ~/.continue/prompts/.
+ */
+export async function discoverContinuePrompts(promptsDir, adapterId) {
+    if (!exists(promptsDir))
+        return [];
+    const found = [];
+    let files;
+    try {
+        files = await fs.readdir(promptsDir);
+    }
+    catch {
+        return [];
+    }
+    for (const file of files) {
+        if (!file.endsWith('.md') && !file.endsWith('.prompt'))
+            continue;
+        const filePath = path.join(promptsDir, file);
+        let description = '';
+        const fm = await readFrontmatter(filePath);
+        if (fm && typeof fm.description === 'string') {
+            description = fm.description;
+        }
+        const name = file.replace(/\.(md|prompt)$/, '');
+        found.push({
+            id: makeAssetId(),
+            type: 'prompt',
+            name: slugifyImportName(name),
+            description: description || `Continue prompt "${name}"`,
+            sourcePath: filePath,
+            originLabel: `~/.continue/prompts/${file}`,
+            canonicalStatus: 'convertible',
+            canonicalNote: 'Prompt file will be normalized to PROMPT.md',
+            confidence: 85,
+            adapterId,
+            provenance: {
+                tool: adapterId,
+                sourcePath: filePath,
+                importedAt: new Date().toISOString(),
+            },
+        });
+    }
+    return found;
+}
+/**
+ * Discover MCP servers from Continue's config.json (legacy) or config.yaml.
+ */
+export async function discoverContinueMcpFromConfig(configPath, adapterId) {
+    if (!exists(configPath))
+        return [];
+    try {
+        const text = await fs.readFile(configPath, 'utf-8');
+        let data = null;
+        if (configPath.endsWith('.json')) {
+            data = JSON.parse(text);
+        }
+        else if (configPath.endsWith('.yaml') || configPath.endsWith('.yml')) {
+            const yaml = await import('js-yaml');
+            const parsed = yaml.load(text);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                data = parsed;
+            }
+        }
+        if (!data)
+            return [];
+        const servers = extractMcpServerMap(data);
+        const results = [];
+        for (const [serverName, config] of Object.entries(servers)) {
+            if (!config || typeof config !== 'object')
+                continue;
+            const home = os.homedir();
+            results.push({
+                id: makeAssetId(),
+                type: 'mcp',
+                name: slugifyImportName(serverName),
+                description: `Continue MCP server "${serverName}"`,
+                sourcePath: configPath,
+                originLabel: `${configPath.replace(home, '~')} → ${serverName}`,
+                canonicalStatus: 'convertible',
+                canonicalNote: `Will extract server "${serverName}" into canonical mcp.json`,
+                confidence: 80,
+                adapterId,
+                mcpServerName: serverName,
+                provenance: {
+                    tool: adapterId,
+                    sourcePath: configPath,
+                    importedAt: new Date().toISOString(),
+                },
+            });
+        }
+        return results;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Discover canonical assets from an existing Aman environment directory.
+ */
+export async function discoverAmanEnvironmentAssets(envRoot, adapterId) {
+    const found = [];
+    const home = os.homedir();
+    const typeMap = [
+        { type: 'skill', dir: path.join(envRoot, 'skills'), contentFile: 'SKILL.md' },
+        { type: 'prompt', dir: path.join(envRoot, 'prompts'), contentFile: 'PROMPT.md' },
+        { type: 'mcp', dir: path.join(envRoot, 'mcps'), contentFile: 'mcp.json' },
+    ];
+    for (const { type, dir, contentFile } of typeMap) {
+        if (!exists(dir))
+            continue;
+        let entries;
+        try {
+            const dirents = await fs.readdir(dir, { withFileTypes: true });
+            entries = dirents.filter((d) => d.isDirectory()).map((d) => d.name);
+        }
+        catch {
+            continue;
+        }
+        for (const name of entries) {
+            const assetPath = path.join(dir, name);
+            const content = path.join(assetPath, contentFile);
+            if (!exists(content))
+                continue;
+            const hasMeta = exists(path.join(assetPath, 'metadata.json'));
+            let description = '';
+            if (hasMeta) {
+                const meta = await readJson(path.join(assetPath, 'metadata.json'));
+                if (meta && typeof meta.description === 'string') {
+                    description = meta.description;
+                }
+            }
+            else if (type === 'skill' || type === 'prompt') {
+                const fm = await readFrontmatter(content);
+                if (fm && typeof fm.description === 'string') {
+                    description = fm.description;
+                }
+            }
+            found.push({
+                id: makeAssetId(),
+                type,
+                name: slugifyImportName(name),
+                description,
+                sourcePath: assetPath,
+                originLabel: assetPath.replace(home, '~'),
+                canonicalStatus: hasMeta ? 'canonical' : 'convertible',
+                canonicalNote: hasMeta ? undefined : 'Will generate metadata.json on import',
+                confidence: hasMeta ? 95 : 85,
+                adapterId,
+                provenance: {
+                    tool: 'aman',
+                    sourcePath: assetPath,
+                    importedAt: new Date().toISOString(),
+                },
+            });
+        }
+    }
+    return found;
+}

package/dist/marketplace/cache.d.ts

@@ -0,0 +1,18 @@
+import { MarketplaceAsset } from './types.js';
+export declare const MARKETPLACE_CACHE_DIR: string;
+export declare const MARKETPLACE_CACHE_TTL_MS: number;
+export declare function marketplaceCacheKey(query: string, typeFilter: string): string;
+export declare function readMarketplaceCache(query: string, typeFilter: string): Promise<{
+    assets: MarketplaceAsset[];
+    fetchedAt: Date;
+    ageMs: number;
+} | null>;
+export declare function writeMarketplaceCache(query: string, typeFilter: string, assets: MarketplaceAsset[]): Promise<void>;
+export declare function isCacheFresh(ageMs: number): boolean;
+export declare function getMarketplaceCacheStatus(): Promise<{
+    entryCount: number;
+    totalBytes: number;
+    oldestAgeMinutes: number | null;
+    newestAgeMinutes: number | null;
+}>;
+export declare function clearMarketplaceCache(): Promise<number>;

package/dist/marketplace/cache.js

@@ -0,0 +1,141 @@
+import path from 'path';
+import { createHash } from 'crypto';
+import { GLOBAL_CACHE } from '../config/paths.js';
+import { ensureDir, readJson, writeJson, removeDir } from '../storage/filesystem.js';
+import { promises as fs } from 'fs';
+import { parsePublisherMetadata } from './metadata-validator.js';
+export const MARKETPLACE_CACHE_DIR = path.join(GLOBAL_CACHE, 'marketplace');
+const INDEX_FILE = path.join(MARKETPLACE_CACHE_DIR, 'index.json');
+export const MARKETPLACE_CACHE_TTL_MS = 60 * 60 * 1000;
+export function marketplaceCacheKey(query, typeFilter) {
+    return createHash('sha256').update(`${query}\0${typeFilter}`).digest('hex').slice(0, 24);
+}
+function cacheFilePath(key) {
+    return path.join(MARKETPLACE_CACHE_DIR, `${key}.json`);
+}
+async function readIndex() {
+    const data = await readJson(INDEX_FILE);
+    if (data?.version === 1 && Array.isArray(data.entries))
+        return data;
+    return { version: 1, entries: [] };
+}
+async function writeIndex(index) {
+    await ensureDir(MARKETPLACE_CACHE_DIR);
+    await writeJson(INDEX_FILE, index);
+}
+function validateCachedAsset(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const a = raw;
+    if (a.type !== 'skill' && a.type !== 'prompt' && a.type !== 'mcp')
+        return null;
+    if (typeof a.slug !== 'string' || typeof a.name !== 'string')
+        return null;
+    if (typeof a.source !== 'string' || !a.source.startsWith('github:'))
+        return null;
+    try {
+        parsePublisherMetadata({
+            schemaVersion: 1,
+            id: a.id ?? a.slug,
+            slug: a.slug,
+            type: a.type,
+            name: a.localName ?? a.name,
+            description: a.description ?? '',
+            version: a.version ?? '1.0.0',
+            author: a.author ?? 'unknown',
+            tags: a.tags ?? [],
+            integrity: { algorithm: 'sha256', checksum: a.checksum, signature: null },
+        }, a.type, a.localName ?? a.name, a.slug, a.author ?? 'unknown');
+    }
+    catch {
+        return null;
+    }
+    return {
+        ...a,
+        verified: a.slug.startsWith('@aman/'),
+    };
+}
+export async function readMarketplaceCache(query, typeFilter) {
+    const key = marketplaceCacheKey(query, typeFilter);
+    const file = cacheFilePath(key);
+    const payload = await readJson(file);
+    if (!payload?.fetchedAt || !Array.isArray(payload.assets))
+        return null;
+    const valid = [];
+    for (const item of payload.assets) {
+        const v = validateCachedAsset(item);
+        if (v)
+            valid.push(v);
+    }
+    if (valid.length !== payload.assets.length) {
+        await fs.unlink(file).catch(() => { });
+        const index = await readIndex();
+        index.entries = index.entries.filter((e) => e.key !== key);
+        await writeIndex(index);
+        return null;
+    }
+    const fetchedAt = new Date(payload.fetchedAt);
+    return { assets: valid, fetchedAt, ageMs: Date.now() - fetchedAt.getTime() };
+}
+export async function writeMarketplaceCache(query, typeFilter, assets) {
+    await ensureDir(MARKETPLACE_CACHE_DIR);
+    const key = marketplaceCacheKey(query, typeFilter);
+    const fetchedAt = new Date().toISOString();
+    const payload = {
+        version: 1,
+        fetchedAt,
+        query,
+        typeFilter,
+        assets,
+    };
+    await writeJson(cacheFilePath(key), payload);
+    const index = await readIndex();
+    const entry = {
+        key,
+        query,
+        typeFilter,
+        fetchedAt,
+        file: `${key}.json`,
+        assetCount: assets.length,
+    };
+    const existing = index.entries.findIndex((e) => e.key === key);
+    if (existing >= 0)
+        index.entries[existing] = entry;
+    else
+        index.entries.push(entry);
+    await writeIndex(index);
+}
+export function isCacheFresh(ageMs) {
+    return ageMs < MARKETPLACE_CACHE_TTL_MS;
+}
+export async function getMarketplaceCacheStatus() {
+    await ensureDir(MARKETPLACE_CACHE_DIR);
+    const index = await readIndex();
+    let totalBytes = 0;
+    const ages = [];
+    const now = Date.now();
+    for (const entry of index.entries) {
+        const file = cacheFilePath(entry.key);
+        try {
+            const stat = await fs.stat(file);
+            totalBytes += stat.size;
+            ages.push(now - new Date(entry.fetchedAt).getTime());
+        }
+        catch {
+            // orphan index entry
+        }
+    }
+    return {
+        entryCount: index.entries.length,
+        totalBytes,
+        oldestAgeMinutes: ages.length ? Math.round(Math.max(...ages) / 60000) : null,
+        newestAgeMinutes: ages.length ? Math.round(Math.min(...ages) / 60000) : null,
+    };
+}
+export async function clearMarketplaceCache() {
+    const index = await readIndex();
+    const count = index.entries.length;
+    await removeDir(MARKETPLACE_CACHE_DIR);
+    await ensureDir(MARKETPLACE_CACHE_DIR);
+    return count;
+}

package/dist/marketplace/github-search.d.ts

@@ -0,0 +1,17 @@
+import { MarketplaceAsset, MarketplaceSearchResult, MarketplaceTypeFilter } from './types.js';
+/**
+ * Search GitHub for `topic:aman-asset` publisher repos and load validated metadata.
+ * Uses ~/.aman/cache/marketplace/ with 1h TTL; serves stale cache on rate limit/offline.
+ */
+export declare function searchGitHubMarketplace(options: {
+    query?: string;
+    typeFilter?: MarketplaceTypeFilter;
+    sort?: 'stars' | 'recent' | 'name';
+    forceRefresh?: boolean;
+}): Promise<MarketplaceSearchResult>;
+export declare function indexMarketplaceAssets(assets: MarketplaceAsset[]): void;
+export declare function findMarketplaceAsset(ref: string): MarketplaceAsset | undefined;
+export declare function loadMarketplaceIndex(options?: {
+    query?: string;
+    typeFilter?: MarketplaceTypeFilter;
+}): Promise<MarketplaceSearchResult>;