aman-intelligence 0.1.0

package/dist/import/import.service.js

@@ -0,0 +1,259 @@
+import os from 'os';
+import path from 'path';
+import { promises as fs } from 'fs';
+import { exists, ensureDir, readJson, writeJson, removeDir, copyDir } from '../storage/filesystem.js';
+import { assetService } from '../services/asset.service.js';
+import { environmentService } from '../services/environment.service.js';
+import { codexBlockToMcpJson, extractMcpServerMap, parseCodexMcpBlocks, slugifyImportName, } from './utils.js';
+function buildProvenanceSource(adapterId, originLabel) {
+    return `import:${adapterId}:${originLabel}`;
+}
+export function isGithubDestinationAvailable() {
+    const storage = environmentService.getStorage();
+    return storage.type === 'github' && Boolean(storage.repository);
+}
+export async function detectImportConflicts(items, scope) {
+    const conflicts = [];
+    for (const item of items) {
+        const existing = await assetService.list(item.type, scope);
+        const match = existing.find((e) => e.name === item.name);
+        if (match) {
+            conflicts.push({
+                asset: item,
+                existingLocalName: match.name,
+                resolution: 'skip',
+                resolvedName: item.name,
+            });
+        }
+    }
+    return conflicts;
+}
+async function stageMcpAsset(item, stagingRoot) {
+    const dest = path.join(stagingRoot, item.id);
+    await ensureDir(dest);
+    if (item.adapterId === 'codex' && item.mcpServerName && item.sourcePath.endsWith('.toml')) {
+        const text = await fs.readFile(item.sourcePath, 'utf-8');
+        const block = parseCodexMcpBlocks(text).find((b) => b.name === item.mcpServerName);
+        if (!block)
+            throw new Error(`Codex MCP block not found: ${item.mcpServerName}`);
+        const mcpJson = codexBlockToMcpJson(block);
+        await writeJson(path.join(dest, 'mcp.json'), mcpJson);
+        await separateMcpSecrets(dest);
+        return dest;
+    }
+    if (item.mcpServerName) {
+        const raw = await readJson(item.sourcePath);
+        if (!raw)
+            throw new Error(`Invalid MCP config: ${item.sourcePath}`);
+        const servers = extractMcpServerMap(raw);
+        const serverConfig = servers[item.mcpServerName];
+        if (!serverConfig)
+            throw new Error(`MCP server "${item.mcpServerName}" not found in ${item.sourcePath}`);
+        await writeJson(path.join(dest, 'mcp.json'), { mcpServers: { [item.mcpServerName]: serverConfig } });
+        await separateMcpSecrets(dest);
+        return dest;
+    }
+    if (exists(path.join(item.sourcePath, 'mcp.json'))) {
+        await copyDir(item.sourcePath, dest);
+        await separateMcpSecrets(dest);
+        return dest;
+    }
+    if (item.sourcePath.endsWith('.json') && exists(item.sourcePath)) {
+        const raw = await readJson(item.sourcePath);
+        if (raw && extractMcpServerMap(raw)) {
+            await writeJson(path.join(dest, 'mcp.json'), raw.mcpServers ? raw : { mcpServers: extractMcpServerMap(raw) });
+            await separateMcpSecrets(dest);
+            return dest;
+        }
+        await fs.copyFile(item.sourcePath, path.join(dest, 'mcp.json'));
+        await separateMcpSecrets(dest);
+        return dest;
+    }
+    throw new Error(`Cannot stage MCP from ${item.originLabel}`);
+}
+/**
+ * Separate machine-specific secrets from portable mcp.json.
+ * Reads env vars, moves actual values to mcp.local.json,
+ * replaces them with placeholders in mcp.json.
+ */
+async function separateMcpSecrets(assetDir) {
+    const mcpPath = path.join(assetDir, 'mcp.json');
+    const localPath = path.join(assetDir, 'mcp.local.json');
+    if (!exists(mcpPath) || exists(localPath))
+        return;
+    const mcpData = await readJson(mcpPath);
+    if (!mcpData)
+        return;
+    const localValues = {};
+    let modified = false;
+    // Walk mcpServers.*.env to find non-placeholder values
+    const mcpServers = mcpData.mcpServers;
+    if (mcpServers && typeof mcpServers === 'object') {
+        for (const [, serverCfg] of Object.entries(mcpServers)) {
+            if (!serverCfg || typeof serverCfg !== 'object')
+                continue;
+            const env = serverCfg.env;
+            if (!env || typeof env !== 'object' || Array.isArray(env))
+                continue;
+            for (const [key, value] of Object.entries(env)) {
+                if (typeof value !== 'string')
+                    continue;
+                // Detect actual secret values (not already placeholders)
+                const isPlaceholder = /^\$\{[A-Z0-9_]+\}$|^\{\{[A-Z0-9_]+\}\}$|^\$[A-Z][A-Z0-9_]*$/.test(value.trim());
+                const isEmpty = value.trim() === '';
+                if (!isPlaceholder && !isEmpty && looksLikeSecret(key, value)) {
+                    localValues[key] = value;
+                    env[key] = `\${${key}}`;
+                    modified = true;
+                }
+            }
+        }
+    }
+    if (modified) {
+        await writeJson(mcpPath, mcpData);
+        await writeJson(localPath, {
+            _comment: 'Fill in local values for this MCP. This file is gitignored and never synced.',
+            ...localValues,
+        });
+    }
+}
+/** Heuristic: keys named token, key, secret, password, auth etc. with non-trivial values. */
+function looksLikeSecret(key, value) {
+    const secretish = /token|key|secret|password|auth|credential|api.?key/i;
+    if (secretish.test(key))
+        return true;
+    // Long opaque strings (API keys, tokens) — 20+ chars, no spaces
+    if (value.length >= 20 && !/\s/.test(value) && /[a-zA-Z0-9\-_]/.test(value))
+        return true;
+    return false;
+}
+async function stageAssetSource(item, stagingRoot) {
+    if (item.type === 'mcp') {
+        return stageMcpAsset(item, stagingRoot);
+    }
+    if (item.type === 'skill') {
+        // Canonical skill directory (has SKILL.md)
+        if (exists(path.join(item.sourcePath, 'SKILL.md'))) {
+            const dest = path.join(stagingRoot, item.id);
+            await copyDir(item.sourcePath, dest);
+            return dest;
+        }
+        // Single rule file (.md, .mdc) → convert to SKILL.md
+        if ((item.sourcePath.endsWith('.md') || item.sourcePath.endsWith('.mdc')) && exists(item.sourcePath)) {
+            const dest = path.join(stagingRoot, item.id);
+            await ensureDir(dest);
+            await fs.copyFile(item.sourcePath, path.join(dest, 'SKILL.md'));
+            return dest;
+        }
+        throw new Error(`Invalid skill source: ${item.sourcePath}`);
+    }
+    if (item.type === 'prompt') {
+        const dest = path.join(stagingRoot, item.id);
+        await ensureDir(dest);
+        if (exists(path.join(item.sourcePath, 'PROMPT.md'))) {
+            await copyDir(item.sourcePath, dest);
+            return dest;
+        }
+        if ((item.sourcePath.endsWith('.md') || item.sourcePath.endsWith('.prompt')) && exists(item.sourcePath)) {
+            await fs.copyFile(item.sourcePath, path.join(dest, 'PROMPT.md'));
+            return dest;
+        }
+        throw new Error(`Invalid prompt source: ${item.sourcePath}`);
+    }
+    throw new Error(`Unsupported asset type: ${item.type}`);
+}
+export async function executeImportPlan(plan) {
+    if (plan.destination === 'github' && !isGithubDestinationAvailable()) {
+        throw new Error('GitHub is not configured. Run `aman init --github` or connect GitHub first.');
+    }
+    if (!environmentService.isEnvironmentInitialized(plan.scope)) {
+        throw new Error('Environment not initialized. Run `aman init --local` first.');
+    }
+    const stagingRoot = path.join(os.tmpdir(), `aman-import-exec-${Date.now()}`);
+    await ensureDir(stagingRoot);
+    const result = {
+        imported: 0,
+        skipped: 0,
+        renamed: 0,
+        overwritten: 0,
+        errors: [],
+    };
+    const installed = [];
+    try {
+        for (const item of plan.items) {
+            const conflict = plan.conflicts.find((c) => c.asset.id === item.id);
+            if (conflict?.resolution === 'skip') {
+                result.skipped++;
+                continue;
+            }
+            let localName = item.name;
+            if (conflict?.resolution === 'rename') {
+                localName = conflict.resolvedName;
+                if (localName !== item.name)
+                    result.renamed++;
+            }
+            else if (conflict?.resolution === 'overwrite') {
+                await assetService.remove(conflict.existingLocalName, item.type, plan.scope);
+                localName = conflict.existingLocalName;
+                result.overwritten++;
+            }
+            try {
+                const stagedPath = await stageAssetSource(item, stagingRoot);
+                const provenanceRef = buildProvenanceSource(plan.sourceId, item.originLabel);
+                const installedAt = new Date().toISOString();
+                const provenance = item.provenance ?? {
+                    tool: plan.sourceId,
+                    sourcePath: item.sourcePath,
+                    importedAt: installedAt,
+                };
+                await assetService.install(localName, item.type, plan.scope, stagedPath, provenanceRef, {
+                    description: item.description,
+                    originalName: item.name !== localName ? item.name : undefined,
+                    tags: [`imported-from-${plan.sourceId}`],
+                    installedAt,
+                    provenance,
+                });
+                installed.push({ type: item.type, name: localName, scope: plan.scope });
+                result.imported++;
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                result.errors.push(`${item.type}/${item.name}: ${msg}`);
+                throw new Error(`Import failed at ${item.name}: ${msg}`);
+            }
+        }
+    }
+    catch (err) {
+        for (const entry of [...installed].reverse()) {
+            await assetService.remove(entry.name, entry.type, entry.scope).catch(() => { });
+        }
+        throw err;
+    }
+    finally {
+        await removeDir(stagingRoot).catch(() => { });
+    }
+    return result;
+}
+export function applyAutoRenameConflicts(conflicts, mode = 'suffix') {
+    return conflicts.map((c) => {
+        if (mode === 'skip')
+            return c;
+        let suffix = 1;
+        let candidate = `${c.asset.name}-imported`;
+        while (candidate === c.existingLocalName) {
+            candidate = `${c.asset.name}-imported-${suffix++}`;
+        }
+        return {
+            ...c,
+            resolution: 'rename',
+            resolvedName: slugifyImportName(candidate),
+        };
+    });
+}
+export function summarizeByType(items) {
+    return {
+        skill: items.filter((i) => i.type === 'skill').length,
+        prompt: items.filter((i) => i.type === 'prompt').length,
+        mcp: items.filter((i) => i.type === 'mcp').length,
+    };
+}

package/dist/import/types.d.ts

@@ -0,0 +1,71 @@
+import { AssetType, Scope } from '../types/index.js';
+export type ImportSourceId = 'claude-code' | 'cursor' | 'windsurf' | 'continue' | 'vscode' | 'github-copilot' | 'codex' | 'local-folder' | 'custom-path' | 'aman-environment' | 'antigravity';
+export type ImportCanonicalStatus = 'canonical' | 'convertible' | 'ambiguous' | 'unknown';
+export type ImportDestination = 'local' | 'github';
+export type TypeSelectionMode = 'all' | 'select' | 'skip';
+export type ConflictResolution = 'skip' | 'rename' | 'overwrite';
+export type ConflictBulkMode = 'ask' | 'rename-all' | 'skip-all' | 'replace-all';
+export interface ImportProvenance {
+    tool: string;
+    sourcePath: string;
+    importedAt: string;
+}
+export interface ImportAdapterDescriptor {
+    id: ImportSourceId;
+    label: string;
+    description: string;
+    available: boolean;
+    unavailableReason?: string;
+}
+export interface DiscoveredImportAsset {
+    /** Stable id within a scan result */
+    id: string;
+    type: AssetType;
+    name: string;
+    description: string;
+    sourcePath: string;
+    originLabel: string;
+    canonicalStatus: ImportCanonicalStatus;
+    canonicalNote?: string;
+    confidence: number;
+    adapterId: ImportSourceId;
+    /** When sourcePath is a multi-server MCP config, the server key to extract */
+    mcpServerName?: string;
+    /** Provenance tracking for imported assets */
+    provenance?: ImportProvenance;
+}
+export interface TypeImportSelection {
+    mode: TypeSelectionMode;
+    selectedIds: Set<string>;
+}
+export interface ImportConflict {
+    asset: DiscoveredImportAsset;
+    existingLocalName: string;
+    resolution: ConflictResolution;
+    resolvedName: string;
+}
+export interface ImportPlan {
+    sourceId: ImportSourceId;
+    sourceLabel: string;
+    destination: ImportDestination;
+    scope: Scope;
+    items: DiscoveredImportAsset[];
+    conflicts: ImportConflict[];
+}
+export interface ImportResult {
+    imported: number;
+    skipped: number;
+    renamed: number;
+    overwritten: number;
+    errors: string[];
+}
+export interface ImportAdapter {
+    id: ImportSourceId;
+    label: string;
+    description: string;
+    isAvailable(): boolean;
+    unavailableReason(): string;
+    scan(options?: {
+        rootPath?: string;
+    }): Promise<DiscoveredImportAsset[]>;
+}

package/dist/import/types.js

@@ -0,0 +1 @@
+export {};

package/dist/import/utils.d.ts

@@ -0,0 +1,36 @@
+import { DiscoveredImportAsset, ImportSourceId } from './types.js';
+export declare function expandHome(inputPath: string): string;
+export declare function vscodeUserMcpPath(): string;
+export declare function slugifyImportName(name: string): string;
+export declare function makeAssetId(): string;
+export declare function discoverSkillDir(skillDir: string, adapterId: ImportSourceId, originLabel: string): Promise<DiscoveredImportAsset | null>;
+export declare function discoverPromptFile(filePath: string, adapterId: ImportSourceId, originLabel: string, suggestedName?: string): Promise<DiscoveredImportAsset>;
+export declare function listSkillDirs(root: string): Promise<string[]>;
+export declare function extractMcpServerMap(raw: Record<string, unknown>): Record<string, unknown>;
+export declare function discoverMcpFromJsonFile(filePath: string, adapterId: ImportSourceId, originPrefix: string): Promise<DiscoveredImportAsset[]>;
+/** Minimal TOML [mcp_servers.name] block parser for Codex config.toml */
+export declare function parseCodexMcpBlocks(tomlText: string): Array<{
+    name: string;
+    body: string;
+}>;
+export declare function codexBlockToMcpJson(block: {
+    name: string;
+    body: string;
+}): Record<string, unknown>;
+/**
+ * Discover rules-style markdown files as skills.
+ * Used by Cursor (.cursor/rules/, .cursorrules) and Windsurf (.windsurf/rules/, .windsurfrules).
+ */
+export declare function discoverRulesAsSkills(rulePaths: string[], dotfilePaths: string[], adapterId: ImportSourceId, originPrefix: string): Promise<DiscoveredImportAsset[]>;
+/**
+ * Discover Continue.dev prompt files from ~/.continue/prompts/.
+ */
+export declare function discoverContinuePrompts(promptsDir: string, adapterId: ImportSourceId): Promise<DiscoveredImportAsset[]>;
+/**
+ * Discover MCP servers from Continue's config.json (legacy) or config.yaml.
+ */
+export declare function discoverContinueMcpFromConfig(configPath: string, adapterId: ImportSourceId): Promise<DiscoveredImportAsset[]>;
+/**
+ * Discover canonical assets from an existing Aman environment directory.
+ */
+export declare function discoverAmanEnvironmentAssets(envRoot: string, adapterId: ImportSourceId): Promise<DiscoveredImportAsset[]>;