evolcore 0.0.1 → 0.0.2

package/dist/core/capability/providers/claude-capability-provider.js

@@ -0,0 +1,176 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { execFileSync } from 'child_process';
+function readJson(file) {
+    try {
+        if (!fs.existsSync(file))
+            return null;
+        return JSON.parse(fs.readFileSync(file, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function listDirectories(dir) {
+    try {
+        if (!fs.existsSync(dir))
+            return [];
+        return fs.readdirSync(dir, { withFileTypes: true })
+            .filter(entry => entry.isDirectory())
+            .map(entry => entry.name);
+    }
+    catch {
+        return [];
+    }
+}
+function readSkillDescription(skillDir) {
+    const file = path.join(skillDir, 'SKILL.md');
+    try {
+        const text = fs.readFileSync(file, 'utf-8');
+        const firstBodyLine = text.split(/\r?\n/)
+            .map(line => line.trim())
+            .find(line => line && !line.startsWith('#') && !line.startsWith('---') && !line.includes(':'));
+        return firstBodyLine ? firstBodyLine.slice(0, 180) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function describeMcpSpec(spec) {
+    const command = typeof spec?.command === 'string' ? spec.command : undefined;
+    if (command)
+        return `stdio: ${path.basename(command)}`;
+    const rawUrl = typeof spec?.url === 'string' ? spec.url : typeof spec?.serverUrl === 'string' ? spec.serverUrl : undefined;
+    if (!rawUrl)
+        return undefined;
+    try {
+        const url = new URL(rawUrl);
+        return `remote: ${url.origin}${url.pathname}`;
+    }
+    catch {
+        return 'remote';
+    }
+}
+function discoverSkills(projectPath) {
+    const roots = [
+        { dir: path.join(projectPath, '.claude', 'skills'), source: 'project' },
+        { dir: path.join(os.homedir(), '.claude', 'skills'), source: 'user' },
+    ];
+    const seen = new Set();
+    const items = [];
+    for (const root of roots) {
+        for (const name of listDirectories(root.dir)) {
+            if (seen.has(name))
+                continue;
+            seen.add(name);
+            items.push({
+                id: name,
+                label: name,
+                desc: readSkillDescription(path.join(root.dir, name)),
+                source: root.source,
+            });
+        }
+    }
+    return items;
+}
+function readMcpServers(projectPath) {
+    const candidates = [
+        { file: path.join(projectPath, '.mcp.json'), source: 'project' },
+        { file: path.join(projectPath, '.claude', 'mcp.json'), source: 'project' },
+        { file: path.join(os.homedir(), '.claude', 'mcp.json'), source: 'user' },
+    ];
+    const seen = new Set();
+    const items = [];
+    for (const candidate of candidates) {
+        const config = readJson(candidate.file);
+        const servers = config?.mcpServers;
+        if (!servers || typeof servers !== 'object')
+            continue;
+        for (const [name, spec] of Object.entries(servers)) {
+            if (seen.has(name))
+                continue;
+            seen.add(name);
+            items.push({
+                id: name,
+                label: name,
+                desc: describeMcpSpec(spec),
+                source: candidate.source,
+                status: 'configured',
+                runtimeEnabled: true,
+                data: spec && typeof spec === 'object' && !Array.isArray(spec) ? { ...spec } : undefined,
+            });
+        }
+    }
+    return items;
+}
+function discoverPlugins(projectPath) {
+    const settingsFiles = [
+        { file: path.join(projectPath, '.claude', 'settings.json'), source: 'project' },
+        { file: path.join(projectPath, '.claude', 'settings.local.json'), source: 'project' },
+        { file: path.join(os.homedir(), '.claude', 'settings.json'), source: 'user' },
+    ];
+    const seen = new Set();
+    const items = [];
+    for (const candidate of settingsFiles) {
+        const settings = readJson(candidate.file);
+        const plugins = settings?.enabledPlugins;
+        if (!plugins || typeof plugins !== 'object')
+            continue;
+        for (const [id, enabled] of Object.entries(plugins)) {
+            if (seen.has(id))
+                continue;
+            seen.add(id);
+            items.push({
+                id,
+                label: id,
+                source: candidate.source,
+                status: enabled === false ? 'disabled' : 'configured',
+                runtimeEnabled: enabled !== false,
+            });
+        }
+    }
+    return items;
+}
+async function discoverPluginsFromCli() {
+    try {
+        const output = execFileSync('claude', ['plugin', 'list', '--json'], {
+            encoding: 'utf-8',
+            timeout: 3000,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const parsed = JSON.parse(output);
+        const list = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.installed) ? parsed.installed : [];
+        return list.map((entry) => {
+            const id = String(entry.id ?? entry.name ?? entry.pluginId ?? '').trim();
+            return id ? {
+                id,
+                label: String(entry.name ?? entry.label ?? id),
+                desc: typeof entry.description === 'string' ? entry.description : undefined,
+                source: 'plugin',
+                status: entry.enabled === false ? 'disabled' : 'installed',
+                runtimeEnabled: entry.enabled !== false,
+            } : null;
+        }).filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+export class ClaudeCapabilityProvider {
+    baseagent = 'claude';
+    getSupport(type) {
+        void type;
+        return { mode: 'inherit', canUpdate: true };
+    }
+    async discover(ctx, type) {
+        if (type === 'skill')
+            return discoverSkills(ctx.projectPath);
+        if (type === 'mcp')
+            return readMcpServers(ctx.projectPath);
+        const fromSettings = discoverPlugins(ctx.projectPath);
+        if (fromSettings.length > 0)
+            return fromSettings;
+        return await discoverPluginsFromCli();
+    }
+}

package/dist/core/capability/providers/codex-capability-provider.js

@@ -0,0 +1,148 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { execFileSync } from 'child_process';
+function listDirectories(dir) {
+    try {
+        if (!fs.existsSync(dir))
+            return [];
+        return fs.readdirSync(dir, { withFileTypes: true })
+            .filter(entry => entry.isDirectory())
+            .map(entry => entry.name);
+    }
+    catch {
+        return [];
+    }
+}
+function discoverSkills(ctx) {
+    const roots = [
+        { dir: path.join(ctx.projectPath, '.codex', 'skills'), source: 'project' },
+        { dir: path.join(os.homedir(), '.codex', 'skills'), source: 'user' },
+        { dir: path.join(os.homedir(), '.codex', 'skills', '.system'), source: 'system' },
+    ];
+    const seen = new Set();
+    const out = [];
+    for (const root of roots) {
+        for (const id of listDirectories(root.dir)) {
+            if (seen.has(id))
+                continue;
+            seen.add(id);
+            out.push({ id, label: id, source: root.source });
+        }
+    }
+    return out;
+}
+function runCodexJson(args) {
+    try {
+        const output = execFileSync('codex', args, {
+            encoding: 'utf-8',
+            timeout: 3000,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        return JSON.parse(output);
+    }
+    catch {
+        return null;
+    }
+}
+function describeMcpEntry(entry) {
+    const command = typeof entry.command === 'string' ? entry.command : undefined;
+    if (command)
+        return `stdio: ${path.basename(command)}`;
+    const rawUrl = typeof entry.url === 'string' ? entry.url : typeof entry.serverUrl === 'string' ? entry.serverUrl : undefined;
+    if (!rawUrl)
+        return undefined;
+    try {
+        const url = new URL(rawUrl);
+        return `remote: ${url.origin}${url.pathname}`;
+    }
+    catch {
+        return 'remote';
+    }
+}
+function normalizeMcpServerConfig(entry) {
+    if (!entry || typeof entry !== 'object')
+        return undefined;
+    const config = {};
+    for (const key of [
+        'command',
+        'args',
+        'env',
+        'cwd',
+        'url',
+        'serverUrl',
+        'bearer_token_env_var',
+        'bearerTokenEnvVar',
+        'http_headers',
+        'httpHeaders',
+        'startup_timeout_sec',
+        'startupTimeoutSec',
+        'startup_timeout_ms',
+        'startupTimeoutMs',
+        'enabled_tools',
+        'enabledTools',
+        'disabled_tools',
+        'disabledTools',
+        'tools',
+        'scope',
+        'oauth',
+        'oauth_resource',
+        'oauthResource',
+    ]) {
+        if (entry[key] !== undefined)
+            config[key] = entry[key];
+    }
+    return Object.keys(config).length > 0 ? config : undefined;
+}
+function discoverMcp() {
+    const parsed = runCodexJson(['mcp', 'list', '--json']);
+    const list = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.servers) ? parsed.servers : [];
+    return list.map((entry) => {
+        const id = String(entry.name ?? entry.id ?? '').trim();
+        if (!id)
+            return null;
+        return {
+            id,
+            label: String(entry.label ?? entry.name ?? id),
+            desc: describeMcpEntry(entry),
+            source: entry.source === 'project' ? 'project' : 'user',
+            status: String(entry.status ?? 'configured'),
+            runtimeEnabled: entry.enabled !== false,
+            data: normalizeMcpServerConfig(entry),
+        };
+    }).filter(Boolean);
+}
+function discoverPlugins() {
+    const parsed = runCodexJson(['plugin', 'list', '--json']);
+    const installed = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.installed) ? parsed.installed : [];
+    return installed.map((entry) => {
+        const id = String(entry.id ?? entry.name ?? entry.pluginId ?? '').trim();
+        if (!id)
+            return null;
+        return {
+            id,
+            label: String(entry.name ?? entry.label ?? id),
+            desc: typeof entry.description === 'string' ? entry.description : undefined,
+            source: 'plugin',
+            status: entry.enabled === false ? 'disabled' : 'installed',
+            runtimeEnabled: entry.enabled !== false,
+        };
+    }).filter(Boolean);
+}
+export class CodexCapabilityProvider {
+    baseagent = 'codex';
+    getSupport(type) {
+        void type;
+        return {
+            mode: 'inherit',
+            canUpdate: true,
+        };
+    }
+    async discover(ctx, type) {
+        if (type === 'skill')
+            return discoverSkills(ctx);
+        if (type === 'mcp')
+            return discoverMcp();
+        return discoverPlugins();
+    }
+}

package/dist/core/capability/providers/gemini-capability-provider.js

@@ -0,0 +1,10 @@
+export class GeminiCapabilityProvider {
+    baseagent = 'gemini';
+    getSupport(type) {
+        void type;
+        return { mode: 'inherit', canUpdate: false, reason: 'Gemini capability 管理尚未接入' };
+    }
+    async discover(_ctx, _type) {
+        return [];
+    }
+}

package/dist/core/capability/types.js

@@ -0,0 +1,27 @@
+export const CAPABILITY_TYPES = ['skill', 'mcp', 'plugin'];
+export function isCapabilityType(value) {
+    return typeof value === 'string' && CAPABILITY_TYPES.includes(value);
+}
+export function normalizeCapabilityTypeConfig(value) {
+    const mode = value?.mode;
+    const overrides = value?.overrides && typeof value.overrides === 'object'
+        ? value.overrides
+        : {};
+    return {
+        mode: mode === 'all' || mode === 'none' || mode === 'inherit' ? mode : 'inherit',
+        overrides: { ...overrides },
+    };
+}
+export function resolveCapabilityEnabled(config, id) {
+    const normalized = normalizeCapabilityTypeConfig(config);
+    const override = normalized.overrides[id];
+    if (override === 'enabled')
+        return true;
+    if (override === 'disabled')
+        return false;
+    if (normalized.mode === 'all')
+        return true;
+    if (normalized.mode === 'none')
+        return false;
+    return 'inherit';
+}

package/dist/core/causation/audit.js

@@ -0,0 +1,103 @@
+import fs from 'fs';
+import path from 'path';
+import { resolvePaths } from '../../paths.js';
+import { LogWriter } from '../../utils/log-writer.js';
+let writer;
+function auditWriter() {
+    writer ??= new LogWriter({
+        baseName: 'causation-spans',
+        logDir: resolvePaths().logs,
+        rotation: 'daily',
+        retention: { days: 7 },
+    });
+    return writer;
+}
+function writeAuditRecord(record) {
+    try {
+        auditWriter().write(JSON.stringify(record));
+    }
+    catch {
+    }
+}
+export function recordCausationSpan(context, type, options = {}) {
+    const record = {
+        version: 1,
+        traceId: context.traceId,
+        spanId: context.spanId,
+        parentSpanId: context.parentSpanId,
+        type,
+        timestamp: options.timestamp ?? Date.now(),
+        status: options.status,
+        refs: options.refs,
+        reason: options.reason,
+    };
+    writeAuditRecord(record);
+}
+export function recordCausationLink(record) {
+    writeAuditRecord({
+        version: 1,
+        ...record,
+        timestamp: record.timestamp ?? Date.now(),
+    });
+}
+export function queryCausationTrace(traceId) {
+    const records = readAuditRecords();
+    const spans = records
+        .filter(isSpanRecord)
+        .filter(record => record.traceId === traceId)
+        .sort((left, right) => left.timestamp - right.timestamp);
+    const spanIds = new Set(spans.map(record => record.spanId));
+    const links = records
+        .filter(isLinkRecord)
+        .filter(record => spanIds.has(record.spanId) || record.linkedTraceId === traceId)
+        .sort((left, right) => left.timestamp - right.timestamp);
+    return { traceId, spans, links };
+}
+function readAuditRecords() {
+    const logDir = resolvePaths().logs;
+    let files;
+    try {
+        files = fs.readdirSync(logDir)
+            .filter(file => file === 'causation-spans.log' || /^causation-spans-\d{8}\.log$/.test(file))
+            .map(file => path.join(logDir, file));
+    }
+    catch {
+        return [];
+    }
+    const records = [];
+    for (const file of files) {
+        let lines;
+        try {
+            lines = fs.readFileSync(file, 'utf8').split('\n');
+        }
+        catch {
+            continue;
+        }
+        for (const line of lines) {
+            if (!line)
+                continue;
+            try {
+                const parsed = JSON.parse(line);
+                if (isSpanRecord(parsed) || isLinkRecord(parsed))
+                    records.push(parsed);
+            }
+            catch {
+            }
+        }
+    }
+    return records;
+}
+function isSpanRecord(value) {
+    return typeof value.traceId === 'string'
+        && typeof value.spanId === 'string'
+        && typeof value.type === 'string';
+}
+function isLinkRecord(value) {
+    return value.relation === 'batch_input'
+        && typeof value.linkedTraceId === 'string'
+        && typeof value.linkedSpanId === 'string';
+}
+export function resetCausationAuditForTests() {
+    writer?.close();
+    writer = undefined;
+}

package/dist/core/causation/aun-association.js

@@ -0,0 +1,111 @@
+import fs from 'fs';
+import path from 'path';
+import { resolvePaths } from '../../paths.js';
+import { atomicReadJson, atomicWriteJson } from '../../utils/atomic-write.js';
+import { cloneCausation, normalizeCausation } from './context.js';
+const DEFAULT_TTL_MS = 30 * 60 * 1000;
+const associations = new Map();
+let loaded = false;
+function associationFile() {
+    return path.join(resolvePaths().dataDir, 'causation-aun.json');
+}
+function ensureLoaded() {
+    if (loaded)
+        return;
+    loaded = true;
+    let raw;
+    try {
+        raw = atomicReadJson(associationFile());
+    }
+    catch {
+        return;
+    }
+    if (!Array.isArray(raw))
+        return;
+    for (const item of raw) {
+        if (!item || typeof item !== 'object' || Array.isArray(item))
+            continue;
+        const record = item;
+        const causation = normalizeCausation(record.causation);
+        if (typeof record.messageId !== 'string'
+            || typeof record.fromAid !== 'string'
+            || typeof record.toAid !== 'string'
+            || typeof record.expiresAt !== 'number'
+            || record.expiresAt <= Date.now()
+            || !causation)
+            continue;
+        associations.set(record.messageId, {
+            fromAid: record.fromAid,
+            toAid: record.toAid,
+            causation,
+            expiresAt: record.expiresAt,
+        });
+    }
+}
+function persist() {
+    try {
+        if (associations.size === 0) {
+            removeAssociationFiles();
+            return;
+        }
+        atomicWriteJson(associationFile(), [...associations].map(([messageId, association]) => ({
+            messageId,
+            ...association,
+        })));
+    }
+    catch {
+    }
+}
+export function registerAunCausation(associationId, fromAid, toAid, causation, ttlMs = DEFAULT_TTL_MS) {
+    ensureLoaded();
+    cleanupExpiredAunCausation();
+    const normalized = normalizeCausation(causation);
+    if (!associationId || !fromAid || !toAid || !normalized)
+        return false;
+    associations.set(associationId, {
+        fromAid,
+        toAid,
+        causation: cloneCausation(normalized),
+        expiresAt: Date.now() + Math.max(1, ttlMs),
+    });
+    persist();
+    return true;
+}
+export function consumeAunCausation(associationId, fromAid, toAid) {
+    ensureLoaded();
+    cleanupExpiredAunCausation();
+    const association = associations.get(associationId);
+    if (!association)
+        return undefined;
+    if (association.fromAid !== fromAid || association.toAid !== toAid)
+        return undefined;
+    associations.delete(associationId);
+    persist();
+    return cloneCausation(association.causation);
+}
+export function cleanupExpiredAunCausation(now = Date.now()) {
+    ensureLoaded();
+    let changed = false;
+    for (const [messageId, association] of associations) {
+        if (association.expiresAt <= now) {
+            associations.delete(messageId);
+            changed = true;
+        }
+    }
+    if (changed)
+        persist();
+}
+export function clearAunCausationForTests() {
+    associations.clear();
+    loaded = true;
+    try {
+        removeAssociationFiles();
+    }
+    catch { }
+}
+function removeAssociationFiles() {
+    const file = associationFile();
+    fs.rmSync(file, { force: true });
+    fs.rmSync(`${file}_`, { force: true });
+    fs.rmSync(`${file}__`, { force: true });
+}

package/dist/core/causation/context.js

@@ -0,0 +1,93 @@
+import crypto from 'crypto';
+import { CAUSATION_VERSION, MAX_TRIGGER_CAUSATION_DEPTH, } from './types.js';
+const ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+function newId(prefix) {
+    return `${prefix}_${crypto.randomUUID().replace(/-/g, '')}`;
+}
+function validId(value) {
+    return typeof value === 'string' && ID_PATTERN.test(value);
+}
+export function cloneCausation(context) {
+    return {
+        version: CAUSATION_VERSION,
+        traceId: context.traceId,
+        spanId: context.spanId,
+        ...(context.parentSpanId ? { parentSpanId: context.parentSpanId } : {}),
+        ...(context.trigger ? { trigger: { path: context.trigger.path.map(node => ({ ...node })) } } : {}),
+    };
+}
+export function normalizeCausation(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const raw = value;
+    if (raw.version !== CAUSATION_VERSION || !validId(raw.traceId) || !validId(raw.spanId))
+        return undefined;
+    if (raw.parentSpanId !== undefined && !validId(raw.parentSpanId))
+        return undefined;
+    let trigger;
+    if (raw.trigger !== undefined) {
+        if (!raw.trigger || typeof raw.trigger !== 'object' || Array.isArray(raw.trigger))
+            return undefined;
+        const path = raw.trigger.path;
+        if (!Array.isArray(path) || path.length === 0 || path.length > MAX_TRIGGER_CAUSATION_DEPTH)
+            return undefined;
+        const normalizedPath = [];
+        for (const node of path) {
+            if (!node || typeof node !== 'object' || Array.isArray(node))
+                return undefined;
+            const record = node;
+            if (!validId(record.triggerId) || !validId(record.runId))
+                return undefined;
+            normalizedPath.push({ triggerId: record.triggerId, runId: record.runId });
+        }
+        trigger = { path: normalizedPath };
+    }
+    return {
+        version: CAUSATION_VERSION,
+        traceId: raw.traceId,
+        spanId: raw.spanId,
+        ...(raw.parentSpanId ? { parentSpanId: raw.parentSpanId } : {}),
+        ...(trigger ? { trigger } : {}),
+    };
+}
+export function createRootCausation() {
+    return {
+        version: CAUSATION_VERSION,
+        traceId: newId('trace'),
+        spanId: newId('span'),
+    };
+}
+export function deriveCausation(parent) {
+    const normalized = normalizeCausation(parent);
+    if (!normalized)
+        return createRootCausation();
+    return {
+        version: CAUSATION_VERSION,
+        traceId: normalized.traceId,
+        spanId: newId('span'),
+        parentSpanId: normalized.spanId,
+        ...(normalized.trigger ? { trigger: { path: normalized.trigger.path.map(node => ({ ...node })) } } : {}),
+    };
+}
+export function enterTrigger(parent, triggerId, runId) {
+    const normalized = normalizeCausation(parent);
+    const existingPath = normalized?.trigger?.path ?? [];
+    const matched = existingPath.find(node => node.triggerId === triggerId);
+    if (matched)
+        return { ok: false, reason: 'causation_cycle', matched };
+    if (existingPath.length >= MAX_TRIGGER_CAUSATION_DEPTH) {
+        return { ok: false, reason: 'causation_depth_exceeded' };
+    }
+    const causation = normalized ? deriveCausation(normalized) : createRootCausation();
+    causation.trigger = {
+        path: [...existingPath.map(node => ({ ...node })), { triggerId, runId }],
+    };
+    return { ok: true, causation };
+}
+export function formatTriggerPath(context, nextTriggerId) {
+    const path = normalizeCausation(context)?.trigger?.path ?? [];
+    const formatted = path.map(node => `${node.triggerId}/${node.runId}`);
+    if (nextTriggerId)
+        formatted.push(nextTriggerId);
+    return formatted.join(' -> ');
+}

package/dist/core/causation/index.js

@@ -0,0 +1,4 @@
+export * from './types.js';
+export * from './context.js';
+export * from './audit.js';
+export * from './aun-association.js';

package/dist/core/causation/types.js

@@ -0,0 +1,2 @@
+export const CAUSATION_VERSION = 1;
+export const MAX_TRIGGER_CAUSATION_DEPTH = 16;