aman-intelligence 0.1.0

package/dist/services/classification.service.js

@@ -0,0 +1,271 @@
+import path from 'path';
+import { promises as fs } from 'fs';
+import { GLOBAL_CACHE } from '../config/paths.js';
+import { readJson, writeJson, exists, ensureDir, readFrontmatter } from '../storage/filesystem.js';
+const MEMORY_PATH = path.join(GLOBAL_CACHE, 'classifications.json');
+// ── Patterns for classification ─────────────────────────────────────
+const SKILL_INDICATORS = [
+    /^SKILL\.md$/i,
+    /instructions?/i,
+    /guide/i,
+    /best.?practices/i,
+    /workflow/i,
+    /how.?to/i,
+    /pattern/i,
+    /architecture/i,
+    /setup/i,
+    /conventions?/i,
+];
+const PROMPT_INDICATORS = [
+    /^prompt/i,
+    /\bprompt\b/i,
+    /^system/i,
+    /\brole\b/i,
+    /\byou are\b/i,
+    /\bact as\b/i,
+    /\brespond/i,
+    /\bgenerate\b/i,
+    /\btask\b/i,
+];
+const MCP_INDICATORS = [
+    /mcpServers/i,
+    /\bcommand\b/,
+    /\bargs\b/,
+    /\"servers\"/,
+    /stdio/i,
+    /sse/i,
+    /transport/i,
+];
+const STACK_INDICATORS = [
+    /\bstack\b/i,
+    /\bworkspace\b/i,
+    /\bprofile\b/i,
+    /\"skills\"/,
+    /\"prompts\"/,
+    /\"mcps\"/,
+];
+const IGNORED = new Set(['.git', 'node_modules', 'dist', 'build', '.next', '.aman', '__pycache__']);
+export class ClassificationService {
+    memory = null;
+    // ── Load / save memory ──────────────────────────────────────────
+    async loadMemory() {
+        if (this.memory)
+            return this.memory;
+        this.memory = (await readJson(MEMORY_PATH)) || {};
+        return this.memory;
+    }
+    async saveMemory() {
+        if (!this.memory)
+            return;
+        await ensureDir(path.dirname(MEMORY_PATH));
+        await writeJson(MEMORY_PATH, this.memory);
+    }
+    async remember(relativePath, type) {
+        const mem = await this.loadMemory();
+        mem[relativePath] = type;
+        await this.saveMemory();
+    }
+    async rememberBatch(decisions) {
+        const mem = await this.loadMemory();
+        for (const [key, val] of Object.entries(decisions)) {
+            mem[key] = val;
+        }
+        await this.saveMemory();
+    }
+    async getRemembered(relativePath) {
+        const mem = await this.loadMemory();
+        return mem[relativePath];
+    }
+    // ── Walk a directory ────────────────────────────────────────────
+    async walk(root, base = root) {
+        const entries = await fs.readdir(root, { withFileTypes: true });
+        const files = [];
+        for (const entry of entries) {
+            if (IGNORED.has(entry.name))
+                continue;
+            const full = path.join(root, entry.name);
+            if (entry.isDirectory()) {
+                files.push(...(await this.walk(full, base)));
+            }
+            else if (entry.isFile()) {
+                files.push(full);
+            }
+        }
+        return files;
+    }
+    // ── Classify a single file ──────────────────────────────────────
+    async classifyFile(filePath, rootDir) {
+        const relative = path.relative(rootDir, filePath);
+        const basename = path.basename(filePath);
+        const ext = path.extname(filePath).toLowerCase();
+        // Check memory first
+        const remembered = await this.getRemembered(relative);
+        if (remembered) {
+            return {
+                file: relative,
+                type: remembered,
+                confidence: 100,
+                reason: 'Previously classified',
+            };
+        }
+        // SKILL.md is always a skill marker
+        if (basename === 'SKILL.md') {
+            return { file: relative, type: 'skill', confidence: 99, reason: 'SKILL.md file' };
+        }
+        // JSON files
+        if (ext === '.json') {
+            return await this.classifyJson(filePath, relative);
+        }
+        // Markdown files
+        if (ext === '.md') {
+            return await this.classifyMarkdown(filePath, relative);
+        }
+        return { file: relative, type: 'unknown', confidence: 20, reason: 'Unrecognized file type' };
+    }
+    async classifyJson(filePath, relative) {
+        try {
+            const raw = await fs.readFile(filePath, 'utf-8');
+            const data = JSON.parse(raw);
+            // MCP detection
+            let mcpScore = 0;
+            for (const pattern of MCP_INDICATORS) {
+                if (pattern.test(raw))
+                    mcpScore += 15;
+            }
+            if (data.command || data.mcpServers || data.servers)
+                mcpScore += 30;
+            mcpScore = Math.min(mcpScore, 99);
+            // Stack detection
+            let stackScore = 0;
+            if (data.skills && Array.isArray(data.skills))
+                stackScore += 40;
+            if (data.prompts && Array.isArray(data.prompts))
+                stackScore += 25;
+            if (data.mcps && Array.isArray(data.mcps))
+                stackScore += 25;
+            for (const pattern of STACK_INDICATORS) {
+                if (pattern.test(raw))
+                    stackScore += 5;
+            }
+            stackScore = Math.min(stackScore, 99);
+            if (mcpScore > stackScore && mcpScore >= 50) {
+                return { file: relative, type: 'mcp', confidence: mcpScore, reason: 'MCP configuration detected' };
+            }
+            if (stackScore >= 50) {
+                return { file: relative, type: 'stack', confidence: stackScore, reason: 'Stack definition detected' };
+            }
+            return { file: relative, type: 'unknown', confidence: Math.max(mcpScore, stackScore, 25), reason: 'JSON file, unclear purpose' };
+        }
+        catch {
+            return { file: relative, type: 'unknown', confidence: 10, reason: 'Invalid JSON' };
+        }
+    }
+    async classifyMarkdown(filePath, relative) {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            const frontmatter = await readFrontmatter(filePath);
+            // Check if parent dir has SKILL.md (part of a skill)
+            const parentSkillMd = path.join(path.dirname(filePath), 'SKILL.md');
+            if (exists(parentSkillMd) && path.basename(filePath) !== 'SKILL.md') {
+                return { file: relative, type: 'skill', confidence: 90, reason: 'Part of a skill directory' };
+            }
+            // Frontmatter hints
+            if (frontmatter?.type === 'prompt') {
+                return { file: relative, type: 'prompt', confidence: 98, reason: 'Frontmatter declares prompt' };
+            }
+            if (frontmatter?.type === 'skill') {
+                return { file: relative, type: 'skill', confidence: 98, reason: 'Frontmatter declares skill' };
+            }
+            // Content-based scoring
+            let skillScore = 0;
+            let promptScore = 0;
+            for (const pattern of SKILL_INDICATORS) {
+                if (pattern.test(content.slice(0, 2000)))
+                    skillScore += 10;
+            }
+            for (const pattern of PROMPT_INDICATORS) {
+                if (pattern.test(content.slice(0, 2000)))
+                    promptScore += 12;
+            }
+            // Long documents with headers tend to be skills
+            const headerCount = (content.match(/^#+\s/gm) || []).length;
+            if (headerCount >= 3)
+                skillScore += 15;
+            if (content.length > 3000)
+                skillScore += 10;
+            // Short documents with direct instructions tend to be prompts
+            if (content.length < 2000 && promptScore > 0)
+                promptScore += 15;
+            skillScore = Math.min(skillScore, 97);
+            promptScore = Math.min(promptScore, 97);
+            if (skillScore > promptScore && skillScore >= 50) {
+                return { file: relative, type: 'skill', confidence: skillScore, reason: 'Content matches skill patterns' };
+            }
+            if (promptScore >= 50) {
+                return { file: relative, type: 'prompt', confidence: promptScore, reason: 'Content matches prompt patterns' };
+            }
+            const best = Math.max(skillScore, promptScore);
+            return { file: relative, type: 'unknown', confidence: best || 25, reason: 'Could not determine type' };
+        }
+        catch {
+            return { file: relative, type: 'unknown', confidence: 10, reason: 'Could not read file' };
+        }
+    }
+    // ── Classify an entire directory ────────────────────────────────
+    async classifyDirectory(rootDir) {
+        const files = await this.walk(rootDir);
+        const results = [];
+        // First pass: find SKILL.md markers and mark their parent dirs
+        const skillDirs = new Set();
+        for (const file of files) {
+            if (path.basename(file) === 'SKILL.md') {
+                skillDirs.add(path.dirname(file));
+            }
+        }
+        for (const file of files) {
+            const dir = path.dirname(file);
+            // Skip files inside known skill directories (they're part of the skill)
+            if (skillDirs.has(dir) && path.basename(file) !== 'SKILL.md') {
+                continue;
+            }
+            // Skip files in subdirectories of skill directories
+            let inSkillDir = false;
+            for (const sd of skillDirs) {
+                if (dir.startsWith(sd + path.sep) && dir !== sd) {
+                    inSkillDir = true;
+                    break;
+                }
+            }
+            if (inSkillDir)
+                continue;
+            const result = await this.classifyFile(file, rootDir);
+            results.push(result);
+        }
+        return results;
+    }
+    // ── Summary helpers ─────────────────────────────────────────────
+    summarize(results) {
+        const summary = { skills: 0, prompts: 0, mcps: 0, stacks: 0, unknown: 0 };
+        for (const r of results) {
+            if (r.type === 'skill')
+                summary.skills++;
+            else if (r.type === 'prompt')
+                summary.prompts++;
+            else if (r.type === 'mcp')
+                summary.mcps++;
+            else if (r.type === 'stack')
+                summary.stacks++;
+            else
+                summary.unknown++;
+        }
+        return summary;
+    }
+    /** Auto-import threshold: 50%+ per import confidence bands; below 50 is manual review only. */
+    highConfidence(results, threshold = 50) {
+        return results.filter((r) => r.confidence >= threshold && r.type !== 'unknown');
+    }
+    lowConfidence(results, threshold = 50) {
+        return results.filter((r) => r.confidence < threshold || r.type === 'unknown');
+    }
+}
+export const classificationService = new ClassificationService();

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

@@ -0,0 +1,9 @@
+import { AmanConfig } from '../types/index.js';
+export declare class ConfigService {
+    get<K extends keyof AmanConfig>(key: K): AmanConfig[K];
+    set<K extends keyof AmanConfig>(key: K, value: AmanConfig[K]): void;
+    reset(): void;
+    list(): AmanConfig;
+    validate(): boolean;
+}
+export declare const configService: ConfigService;

package/dist/services/config.service.js

@@ -0,0 +1,20 @@
+import { config } from '../config/index.js';
+export class ConfigService {
+    get(key) {
+        return config.get(key);
+    }
+    set(key, value) {
+        config.set(key, value);
+    }
+    reset() {
+        config.reset();
+    }
+    list() {
+        return config.load();
+    }
+    validate() {
+        const data = this.list();
+        return typeof data === 'object' && data !== null;
+    }
+}
+export const configService = new ConfigService();

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

@@ -0,0 +1,5 @@
+import { HealthCheck } from '../types/index.js';
+export declare class DoctorService {
+    runChecks(scope?: 'global' | 'project'): Promise<HealthCheck[]>;
+}
+export declare const doctorService: DoctorService;

package/dist/services/doctor.service.js

@@ -0,0 +1,186 @@
+import { BUNDLED_SKILLS, BUNDLED_PROMPTS, BUNDLED_MCPS, LOCAL_DIR } from '../config/paths.js';
+import { exists } from '../storage/filesystem.js';
+import { execSync } from 'child_process';
+import { lockService } from './lock.service.js';
+import { environmentService } from './environment.service.js';
+import path from 'path';
+import { migrateScopeLayout, findLayoutViolations, assetDir, metadataFilePath, mcpLocalFilePath } from '../storage/asset-layout.js';
+import { countEmptyMcpLocalValues, gitignoreIncludesMcpLocalAsync } from '../utils/mcp-local.js';
+export class DoctorService {
+    async runChecks(scope = 'global') {
+        const checks = [];
+        const targetDir = scope === 'global' ? environmentService.getActiveEnvironmentDir() : LOCAL_DIR;
+        const dirExists = exists(targetDir);
+        checks.push({
+            name: `${scope} directory exists`,
+            status: dirExists ? 'pass' : 'fail',
+            message: dirExists ? `Found ${targetDir}` : `Missing ${targetDir}`,
+            fix: dirExists ? undefined : `Run 'aman init' to create the environment.`,
+        });
+        const bundledSkills = exists(BUNDLED_SKILLS);
+        const bundledPrompts = exists(BUNDLED_PROMPTS);
+        const bundledMcps = exists(BUNDLED_MCPS);
+        const bundledOk = bundledSkills && bundledPrompts && bundledMcps;
+        const anyBundled = bundledSkills || bundledPrompts || bundledMcps;
+        checks.push({
+            name: `Bundled assets (optional)`,
+            status: bundledOk ? 'pass' : anyBundled ? 'warn' : 'pass',
+            message: bundledOk
+                ? `Optional dev/catalog tree found beside the CLI package`
+                : anyBundled
+                    ? `Partial catalog tree (skills: ${bundledSkills}, prompts: ${bundledPrompts}, mcps: ${bundledMcps})`
+                    : `No bundled assets ship with the CLI — install via registry or import`,
+        });
+        let gitAvailable = false;
+        try {
+            execSync('git --version', { stdio: 'ignore' });
+            gitAvailable = true;
+        }
+        catch {
+            // Ignore
+        }
+        checks.push({
+            name: `Git installed`,
+            status: gitAvailable ? 'pass' : 'warn',
+            message: gitAvailable ? `Git is available` : `Git not found - install git for import/sync features`,
+        });
+        let ghAvailable = false;
+        try {
+            execSync('gh --version', { stdio: 'ignore' });
+            ghAvailable = true;
+        }
+        catch {
+            // Ignore
+        }
+        checks.push({
+            name: `GitHub CLI`,
+            status: ghAvailable ? 'pass' : 'warn',
+            message: ghAvailable ? `GitHub CLI is available` : `GitHub CLI not found - install for sync/GitHub storage`,
+            fix: ghAvailable ? undefined : `Install using winget/brew/apt or scoop`,
+        });
+        if (ghAvailable) {
+            let ghAuth = false;
+            try {
+                execSync('gh auth status', { stdio: 'ignore' });
+                ghAuth = true;
+            }
+            catch {
+                // Ignore
+            }
+            checks.push({
+                name: `GitHub auth`,
+                status: ghAuth ? 'pass' : 'warn',
+                message: ghAuth ? `Authenticated with GitHub` : `Not authenticated with GitHub`,
+                fix: ghAuth ? undefined : `Run 'gh auth login' to authenticate`,
+            });
+        }
+        const nodeVersion = process.version;
+        const isV18 = parseInt(nodeVersion.slice(1).split('.')[0], 10) >= 18;
+        checks.push({
+            name: `Node.js version`,
+            status: isV18 ? 'pass' : 'fail',
+            message: `Running ${nodeVersion}`,
+            fix: isV18 ? undefined : `Upgrade Node.js to v18 or newer.`,
+        });
+        if (dirExists) {
+            await migrateScopeLayout(targetDir);
+            try {
+                await lockService.read(scope);
+                checks.push({
+                    name: `Lockfile valid`,
+                    status: 'pass',
+                    message: `Lockfile parsed successfully`,
+                });
+            }
+            catch {
+                checks.push({
+                    name: `Lockfile valid`,
+                    status: 'fail',
+                    message: `Could not parse aman.lock`,
+                    fix: `Remove and reinstall assets.`,
+                });
+            }
+            try {
+                const lock = await lockService.read(scope);
+                let missingCount = 0;
+                const allEntries = lock.assets;
+                for (const entry of allEntries) {
+                    const typeRoot = entry.type === 'skill'
+                        ? path.join(targetDir, 'skills')
+                        : entry.type === 'prompt'
+                            ? path.join(targetDir, 'prompts')
+                            : path.join(targetDir, 'mcps');
+                    const metaPath = metadataFilePath(assetDir(entry.type, typeRoot, entry.localName));
+                    if (!exists(metaPath)) {
+                        missingCount++;
+                    }
+                }
+                checks.push({
+                    name: `Metadata integrity`,
+                    status: missingCount === 0 ? 'pass' : 'warn',
+                    message: missingCount === 0
+                        ? `All assets have valid metadata`
+                        : `Found ${missingCount} assets with missing metadata`,
+                    fix: missingCount === 0 ? undefined : `Re-install missing assets to regenerate metadata.`,
+                });
+                const violations = await findLayoutViolations(targetDir);
+                checks.push({
+                    name: `Canonical asset layout`,
+                    status: violations.length === 0 ? 'pass' : 'warn',
+                    message: violations.length === 0
+                        ? `All assets use directory layout (SKILL.md / PROMPT.md / mcp.json)`
+                        : `${violations.length} layout issue(s): e.g. ${violations[0].type} "${violations[0].localName}" — ${violations[0].issue}`,
+                    fix: violations.length === 0
+                        ? undefined
+                        : `Run any install command or open the dashboard to auto-migrate flat files to directories.`,
+                });
+                let mcpLocalMissing = 0;
+                let mcpEmptyValues = 0;
+                for (const entry of allEntries) {
+                    if (entry.type !== 'mcp' || !entry.requiresLocalConfig)
+                        continue;
+                    const mcpDir = assetDir('mcp', path.join(targetDir, 'mcps'), entry.localName);
+                    const localSecrets = mcpLocalFilePath(mcpDir);
+                    if (!exists(localSecrets)) {
+                        mcpLocalMissing++;
+                    }
+                    else {
+                        mcpEmptyValues += await countEmptyMcpLocalValues(mcpDir);
+                    }
+                }
+                checks.push({
+                    name: `MCP local configuration`,
+                    status: mcpLocalMissing === 0 ? 'pass' : 'warn',
+                    message: mcpLocalMissing === 0
+                        ? `All MCPs requiring local config have mcp.local.json`
+                        : `${mcpLocalMissing} MCP(s) missing mcp.local.json`,
+                    fix: mcpLocalMissing === 0
+                        ? undefined
+                        : `Re-install the MCP or create mcp.local.json in the asset directory.`,
+                });
+                if (mcpEmptyValues > 0) {
+                    checks.push({
+                        name: `MCP local secrets filled`,
+                        status: 'warn',
+                        message: `${mcpEmptyValues} empty value(s) in mcp.local.json — fill in required secrets`,
+                        fix: `Edit mcps/{name}/mcp.local.json and set non-empty values for each key.`,
+                    });
+                }
+                const gitignoreOk = await gitignoreIncludesMcpLocalAsync(targetDir);
+                checks.push({
+                    name: `mcp.local.json gitignored`,
+                    status: gitignoreOk ? 'pass' : 'fail',
+                    message: gitignoreOk
+                        ? `.gitignore excludes mcps/**/mcp.local.json`
+                        : `mcp.local.json is not listed in ${path.join(targetDir, '.gitignore')}`,
+                    fix: gitignoreOk ? undefined : `Add "mcps/**/mcp.local.json" to .gitignore at the scope root.`,
+                });
+            }
+            catch {
+                // Ignore
+            }
+        }
+        return checks;
+    }
+}
+export const doctorService = new DoctorService();

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

@@ -0,0 +1,42 @@
+export type StorageMode = 'local' | 'github';
+export interface EnvironmentManifest {
+    name: string;
+    version: 1;
+    createdAt: string;
+    storage: {
+        type: StorageMode;
+        repository?: string;
+    };
+}
+export interface InitLocalOptions {
+    storagePath?: string;
+}
+export interface InitGithubOptions {
+    repository: string;
+    mode: 'create' | 'existing';
+}
+export declare class EnvironmentService {
+    getActiveEnvironmentDir(): string;
+    getStorage(): EnvironmentManifest['storage'];
+    getProjectEnvironmentDir(): string;
+    isEnvironmentInitialized(scope?: 'global' | 'project'): boolean;
+    resolveStoragePath(storagePath?: string): string;
+    isGithubCliAvailable(): boolean;
+    installGithubCli(): void;
+    ensureEnvironment(baseDir: string, storage: EnvironmentManifest['storage']): Promise<void>;
+    ensureProjectEnvironment(): Promise<string>;
+    ensureActiveEnvironment(): Promise<string>;
+    initLocal(options?: InitLocalOptions): Promise<string>;
+    initGithub(options: InitGithubOptions): Promise<string>;
+    importStandardized(sourceDir: string, targetDir: string): Promise<void>;
+    private ensureGhAvailable;
+    private addKnownGithubCliPaths;
+    private githubCliInstallAttempts;
+    private ensureGhAuthenticated;
+    private cloneRepository;
+    private gitInit;
+    private gitCommit;
+    private gitCommitAndPush;
+    private createAndPushRepository;
+}
+export declare const environmentService: EnvironmentService;