@feilunxitong/arkit 0.1.0

package/dist/module-kit.js

@@ -0,0 +1,157 @@
+"use strict";
+/**
+ * ModuleKit — 可组合可靠性模块
+ * Gene source: GenericAgent（模块化能力魔方）+ nuwa-skill（认知蒸馏）
+ * Stack minimal modules into composable reliability pipelines.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggingModule = exports.RateLimitModule = exports.ModulePipeline = exports.ModuleBlockError = void 0;
+class ModuleBlockError extends Error {
+    constructor(toolName, reason) {
+        super(`ARK ModulePipe blocked [${toolName}]: ${reason}`);
+        this.name = 'ModuleBlockError';
+    }
+}
+exports.ModuleBlockError = ModuleBlockError;
+class ModulePipeline {
+    name;
+    modules = [];
+    totalCalls = 0;
+    blockedCalls = 0;
+    allowedCalls = 0;
+    constructor(name = 'default-pipeline') {
+        this.name = name;
+    }
+    add(module) {
+        this.modules.push(module);
+        this.modules.sort((a, b) => a.priority - b.priority);
+        return this;
+    }
+    remove(moduleName) {
+        const idx = this.modules.findIndex((m) => m.name === moduleName);
+        if (idx >= 0) {
+            this.modules.splice(idx, 1);
+            return true;
+        }
+        return false;
+    }
+    process(toolName, args) {
+        this.totalCalls++;
+        let context = {};
+        for (const module of this.modules) {
+            if (!module.enabled)
+                continue;
+            const result = module.process(toolName, args, context);
+            context = { ...context, ...(result.context ?? {}) };
+            if (result.action === 'block') {
+                this.blockedCalls++;
+                return {
+                    action: 'block',
+                    reason: `[${module.name}] ${result.reason}`,
+                    context,
+                };
+            }
+            else if (result.action === 'warn') {
+                const warnings = context.warnings ?? [];
+                warnings.push(result.reason);
+                context.warnings = warnings;
+            }
+        }
+        this.allowedCalls++;
+        return { action: 'allow', reason: '', context };
+    }
+    wrap(toolFunc, toolName) {
+        const name = toolName ?? toolFunc.name;
+        const pipeline = this;
+        return function (...args) {
+            const argDict = {};
+            for (let i = 0; i < args.length; i++) {
+                argDict[`arg${i}`] = args[i];
+            }
+            const result = pipeline.process(name, argDict);
+            if (result.action === 'block') {
+                throw new ModuleBlockError(name, result.reason);
+            }
+            return toolFunc.apply(this, args);
+        };
+    }
+    get stats() {
+        return {
+            name: this.name,
+            modules: this.modules.length,
+            totalCalls: this.totalCalls,
+            blocked: this.blockedCalls,
+            allowed: this.allowedCalls,
+            blockRate: `${((this.blockedCalls / Math.max(this.totalCalls, 1)) * 100).toFixed(1)}%`,
+            moduleList: this.modules.map((m) => m.name),
+        };
+    }
+}
+exports.ModulePipeline = ModulePipeline;
+// ─── Built-in Modules ───
+class RateLimitModule {
+    name;
+    enabled = true;
+    priority = 100;
+    maxCallsPerMinute;
+    callTimestamps = [];
+    blocked = 0;
+    passed = 0;
+    constructor(maxCallsPerMinute = 60) {
+        this.maxCallsPerMinute = maxCallsPerMinute;
+        this.name = `rate-limit-${maxCallsPerMinute}pm`;
+    }
+    process(_toolName, _args, context) {
+        const now = Date.now();
+        this.callTimestamps = this.callTimestamps.filter((t) => now - t < 60_000);
+        if (this.callTimestamps.length >= this.maxCallsPerMinute) {
+            this.blocked++;
+            return {
+                action: 'block',
+                reason: `Rate limit: ${this.maxCallsPerMinute}/min exceeded`,
+                context,
+            };
+        }
+        this.callTimestamps.push(now);
+        this.passed++;
+        return { action: 'allow', reason: '', context };
+    }
+    get stats() {
+        return {
+            name: this.name,
+            enabled: this.enabled,
+            limit: `${this.maxCallsPerMinute}/min`,
+            blocked: this.blocked,
+            passed: this.passed,
+            activeInWindow: this.callTimestamps.length,
+        };
+    }
+}
+exports.RateLimitModule = RateLimitModule;
+class LoggingModule {
+    name = 'logging';
+    enabled = true;
+    priority = 999;
+    log = [];
+    maxLogSize = 1000;
+    process(toolName, args, context) {
+        this.log.push({
+            timestamp: Date.now(),
+            tool: toolName,
+            argsKeys: Object.keys(args),
+            warnings: context.warnings ?? [],
+        });
+        if (this.log.length > this.maxLogSize) {
+            this.log = this.log.slice(-this.maxLogSize);
+        }
+        return { action: 'allow', reason: '', context };
+    }
+    get stats() {
+        return {
+            name: this.name,
+            enabled: this.enabled,
+            logSize: this.log.length,
+        };
+    }
+}
+exports.LoggingModule = LoggingModule;

package/dist/multi-agent.d.ts

@@ -0,0 +1,59 @@
+/**
+ * MultiAgentProtocol — 多Agent可靠性协议
+ * Gene source: PraisonAI (⭐8,104) + BMAD-METHOD
+ * Reliable inter-agent messaging: handshake, delivery guarantee, health checks.
+ */
+type MessageStatus = 'pending' | 'delivered' | 'acknowledged' | 'failed' | 'timeout';
+type AgentStatus = 'online' | 'busy' | 'degraded' | 'offline' | 'unknown';
+interface AgentMessage {
+    messageId: string;
+    sender: string;
+    recipient: string;
+    content: Record<string, unknown>;
+    status: MessageStatus;
+    createdAt: number;
+    deliveredAt: number | null;
+    acknowledgedAt: number | null;
+    retryCount: number;
+    maxRetries: number;
+    ttlSeconds: number;
+}
+interface MultiAgentStats {
+    agentId: string;
+    messagesSent: number;
+    messagesDelivered: number;
+    messagesFailed: number;
+    totalRetries: number;
+    totalTimeouts: number;
+    totalHeartbeats: number;
+    activeMessages: number;
+    registeredAgents: number;
+    onlineAgents: number;
+    deliveryRate: string;
+}
+export declare class MultiAgentProtocol {
+    agentId: string;
+    heartbeatInterval: number;
+    private messages;
+    private agents;
+    private totalMessagesSent;
+    private totalMessagesDelivered;
+    private totalMessagesFailed;
+    private totalRetries;
+    private totalHeartbeats;
+    private totalTimeouts;
+    constructor(agentId: string, heartbeatInterval?: number);
+    registerAgent(agentId: string, initialStatus?: AgentStatus): boolean;
+    deregisterAgent(agentId: string): void;
+    sendMessage(recipient: string, content: Record<string, unknown>, maxRetries?: number, ttl?: number): AgentMessage;
+    private tryDeliver;
+    acknowledgeMessage(messageId: string): boolean;
+    retryMessage(messageId: string): boolean;
+    sendHeartbeat(status?: AgentStatus): void;
+    checkAgentHealth(agentId: string, maxAge?: number): AgentStatus;
+    getOnlineAgents(): string[];
+    collectGarbage(): void;
+    get stats(): MultiAgentStats;
+    get networkMap(): string;
+}
+export {};

package/dist/multi-agent.js

@@ -0,0 +1,192 @@
+"use strict";
+/**
+ * MultiAgentProtocol — 多Agent可靠性协议
+ * Gene source: PraisonAI (⭐8,104) + BMAD-METHOD
+ * Reliable inter-agent messaging: handshake, delivery guarantee, health checks.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiAgentProtocol = void 0;
+function generateId() {
+    return Math.random().toString(36).slice(2, 14);
+}
+class MultiAgentProtocol {
+    agentId;
+    heartbeatInterval;
+    messages = new Map();
+    agents = new Map();
+    totalMessagesSent = 0;
+    totalMessagesDelivered = 0;
+    totalMessagesFailed = 0;
+    totalRetries = 0;
+    totalHeartbeats = 0;
+    totalTimeouts = 0;
+    constructor(agentId, heartbeatInterval = 5_000) {
+        this.agentId = agentId;
+        this.heartbeatInterval = heartbeatInterval;
+    }
+    registerAgent(agentId, initialStatus = 'online') {
+        if (!this.agents.has(agentId)) {
+            this.agents.set(agentId, {
+                agentId,
+                status: initialStatus,
+                lastSeen: Date.now(),
+                messageCount: 0,
+                errorCount: 0,
+                avgResponseMs: 0,
+            });
+            return true;
+        }
+        const agent = this.agents.get(agentId);
+        agent.status = 'online';
+        agent.lastSeen = Date.now();
+        return false;
+    }
+    deregisterAgent(agentId) {
+        const agent = this.agents.get(agentId);
+        if (agent) {
+            agent.status = 'offline';
+        }
+    }
+    sendMessage(recipient, content, maxRetries = 3, ttl = 30) {
+        const msg = {
+            messageId: generateId(),
+            sender: this.agentId,
+            recipient,
+            content,
+            status: 'pending',
+            createdAt: Date.now(),
+            deliveredAt: null,
+            acknowledgedAt: null,
+            retryCount: 0,
+            maxRetries,
+            ttlSeconds: ttl,
+        };
+        this.messages.set(msg.messageId, msg);
+        this.totalMessagesSent++;
+        this.tryDeliver(msg);
+        return msg;
+    }
+    tryDeliver(msg) {
+        const recipient = this.agents.get(msg.recipient);
+        if (recipient && recipient.status !== 'offline' && recipient.status !== 'unknown') {
+            msg.status = 'delivered';
+            msg.deliveredAt = Date.now();
+            this.totalMessagesDelivered++;
+        }
+        else {
+            msg.status = 'failed';
+            this.totalMessagesFailed++;
+        }
+    }
+    acknowledgeMessage(messageId) {
+        const msg = this.messages.get(messageId);
+        if (msg && msg.status === 'delivered') {
+            msg.status = 'acknowledged';
+            msg.acknowledgedAt = Date.now();
+            return true;
+        }
+        return false;
+    }
+    retryMessage(messageId) {
+        const msg = this.messages.get(messageId);
+        if (!msg)
+            return false;
+        if (msg.retryCount >= msg.maxRetries) {
+            msg.status = 'timeout';
+            this.totalTimeouts++;
+            return false;
+        }
+        msg.retryCount++;
+        this.totalRetries++;
+        this.tryDeliver(msg);
+        return true;
+    }
+    sendHeartbeat(status = 'online') {
+        const existing = this.agents.get(this.agentId);
+        if (!existing) {
+            this.agents.set(this.agentId, {
+                agentId: this.agentId,
+                status,
+                lastSeen: Date.now(),
+                messageCount: 0,
+                errorCount: 0,
+                avgResponseMs: 0,
+            });
+        }
+        else {
+            existing.status = status;
+            existing.lastSeen = Date.now();
+        }
+        this.totalHeartbeats++;
+    }
+    checkAgentHealth(agentId, maxAge = 15_000) {
+        const agent = this.agents.get(agentId);
+        if (!agent)
+            return 'unknown';
+        if (Date.now() - agent.lastSeen > maxAge) {
+            agent.status = 'offline';
+            return 'offline';
+        }
+        return agent.status;
+    }
+    getOnlineAgents() {
+        const now = Date.now();
+        const result = [];
+        for (const [id, agent] of this.agents) {
+            if (agent.status === 'online' && now - agent.lastSeen < 15_000) {
+                result.push(id);
+            }
+        }
+        return result;
+    }
+    collectGarbage() {
+        const now = Date.now();
+        // Expire old messages
+        for (const [id, msg] of this.messages) {
+            if (now - msg.createdAt > msg.ttlSeconds * 1000) {
+                this.messages.delete(id);
+            }
+        }
+        // Mark stale agents offline
+        for (const [, agent] of this.agents) {
+            if (now - agent.lastSeen > 30_000) {
+                agent.status = 'offline';
+            }
+        }
+    }
+    get stats() {
+        return {
+            agentId: this.agentId,
+            messagesSent: this.totalMessagesSent,
+            messagesDelivered: this.totalMessagesDelivered,
+            messagesFailed: this.totalMessagesFailed,
+            totalRetries: this.totalRetries,
+            totalTimeouts: this.totalTimeouts,
+            totalHeartbeats: this.totalHeartbeats,
+            activeMessages: this.messages.size,
+            registeredAgents: this.agents.size,
+            onlineAgents: this.getOnlineAgents().length,
+            deliveryRate: `${((this.totalMessagesDelivered / Math.max(this.totalMessagesSent, 1)) * 100).toFixed(1)}%`,
+        };
+    }
+    get networkMap() {
+        const lines = [`🌐 ARK Multi-Agent Network: ${this.agentId}`];
+        const statusIcons = {
+            online: '🟢',
+            busy: '🟡',
+            degraded: '🟠',
+            offline: '🔴',
+            unknown: '⚪',
+        };
+        for (const [, agent] of this.agents) {
+            const icon = statusIcons[agent.status] ?? '❓';
+            const age = (Date.now() - agent.lastSeen) / 1000;
+            lines.push(`  ${icon} ${agent.agentId} (seen ${age.toFixed(0)}s ago, ${agent.messageCount} msgs)`);
+        }
+        const s = this.stats;
+        lines.push(`  ────`);
+        lines.push(`  📊 Delivery: ${s.deliveryRate} | Active msgs: ${s.activeMessages}`);
+        return lines.join('\n');
+    }
+}
+exports.MultiAgentProtocol = MultiAgentProtocol;

package/dist/proactive.d.ts

@@ -0,0 +1,45 @@
+/**
+ * ProactiveGuard — 预测性失败检测
+ * Gene source: memU（意图捕获，⭐13,813）
+ * Predict potential failures before they happen by learning from patterns.
+ */
+export declare class ProactiveBlockError extends Error {
+    toolName: string;
+    risk: number;
+    constructor(toolName: string, risk: number, reason: string);
+}
+interface ProactiveGuardStats {
+    name: string;
+    sensitivity: number;
+    patternsLearned: number;
+    predictionsMade: number;
+    blockedCalls: number;
+    allowedCalls: number;
+    accuracy: string;
+    historySize: number;
+    riskThreshold: number;
+}
+export declare class ProactiveGuard {
+    name: string;
+    sensitivity: number;
+    historySize: number;
+    private patterns;
+    private callHistory;
+    private predictions;
+    private correctPredictions;
+    private falsePositives;
+    private blockedCalls;
+    private allowedCalls;
+    private totalPatterns;
+    constructor(name?: string, sensitivity?: number, historySize?: number);
+    recordFailure(toolName: string, args: Record<string, unknown>, error: string): void;
+    recordSuccess(toolName: string, args: Record<string, unknown>): void;
+    private trimHistory;
+    predictRisk(toolName: string, args: Record<string, unknown>): number;
+    shouldBlock(toolName: string, args: Record<string, unknown>): [boolean, number, string];
+    recordPredictionOutcome(blocked: boolean, succeeded: boolean): void;
+    get accuracy(): number;
+    get stats(): ProactiveGuardStats;
+    get riskReport(): string;
+}
+export {};

package/dist/proactive.js

@@ -0,0 +1,183 @@
+"use strict";
+/**
+ * ProactiveGuard — 预测性失败检测
+ * Gene source: memU（意图捕获，⭐13,813）
+ * Predict potential failures before they happen by learning from patterns.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProactiveGuard = exports.ProactiveBlockError = void 0;
+class ProactiveBlockError extends Error {
+    toolName;
+    risk;
+    constructor(toolName, risk, reason) {
+        super(`ARK ProactiveGuard blocked [${toolName}]. Risk: ${(risk * 100).toFixed(0)}%. ${reason}`);
+        this.name = 'ProactiveBlockError';
+        this.toolName = toolName;
+        this.risk = risk;
+    }
+}
+exports.ProactiveBlockError = ProactiveBlockError;
+function simpleHash(s) {
+    let hash = 0;
+    for (let i = 0; i < s.length; i++) {
+        const char = s.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash |= 0;
+    }
+    return Math.abs(hash).toString(16).padStart(8, '0');
+}
+class ProactiveGuard {
+    name;
+    sensitivity;
+    historySize;
+    patterns = new Map();
+    callHistory = [];
+    predictions = 0;
+    correctPredictions = 0;
+    falsePositives = 0;
+    blockedCalls = 0;
+    allowedCalls = 0;
+    totalPatterns = 0;
+    constructor(name = 'proactive-guard', sensitivity = 0.3, historySize = 1000) {
+        this.name = name;
+        this.sensitivity = sensitivity;
+        this.historySize = historySize;
+    }
+    recordFailure(toolName, args, error) {
+        const sig = JSON.stringify(args, Object.keys(args).sort());
+        const key = `${toolName}::${simpleHash(sig).slice(0, 8)}`;
+        if (!this.patterns.has(key)) {
+            this.patterns.set(key, {
+                toolName,
+                paramSignature: sig,
+                failureCount: 0,
+                lastSeen: Date.now(),
+                errorSamples: [],
+            });
+            this.totalPatterns++;
+        }
+        const pattern = this.patterns.get(key);
+        pattern.failureCount++;
+        pattern.lastSeen = Date.now();
+        if (pattern.errorSamples.length < 5) {
+            pattern.errorSamples.push(error.slice(0, 100));
+        }
+        this.callHistory.push({
+            timestamp: Date.now(),
+            tool: toolName,
+            argsSig: sig.slice(0, 20),
+            success: false,
+            error: error.slice(0, 50),
+        });
+        this.trimHistory();
+    }
+    recordSuccess(toolName, args) {
+        const sig = JSON.stringify(args, Object.keys(args).sort());
+        this.callHistory.push({
+            timestamp: Date.now(),
+            tool: toolName,
+            argsSig: sig.slice(0, 20),
+            success: true,
+        });
+        this.trimHistory();
+    }
+    trimHistory() {
+        if (this.callHistory.length > this.historySize) {
+            this.callHistory = this.callHistory.slice(-this.historySize);
+        }
+    }
+    predictRisk(toolName, args) {
+        const sig = JSON.stringify(args, Object.keys(args).sort());
+        const key = `${toolName}::${simpleHash(sig).slice(0, 8)}`;
+        // 1. Exact pattern match
+        if (this.patterns.has(key)) {
+            const pattern = this.patterns.get(key);
+            const recent = this.callHistory
+                .slice(-20)
+                .filter((c) => !c.success && c.tool === toolName)
+                .length;
+            const freq = pattern.failureCount / Math.max(this.callHistory.length, 1);
+            const recency = 1 / (1 + (Date.now() - pattern.lastSeen) / 60_000);
+            return Math.min(1, freq * 0.7 + recency * 0.3);
+        }
+        // 2. Tool-level risk
+        const recentCalls = this.callHistory
+            .slice(-50)
+            .filter((c) => c.tool === toolName);
+        if (recentCalls.length > 0) {
+            const failRate = recentCalls.filter((c) => !c.success).length / recentCalls.length;
+            return failRate * 0.5;
+        }
+        // 3. Unknown operation → conservative (0 for no history)
+        if (this.callHistory.length === 0)
+            return 0;
+        // 4. Global trend
+        const globalRecent = this.callHistory.slice(-50);
+        const globalFailRate = globalRecent.filter((c) => !c.success).length /
+            Math.max(globalRecent.length, 1);
+        return globalFailRate * 0.3;
+    }
+    shouldBlock(toolName, args) {
+        const risk = this.predictRisk(toolName, args);
+        if (risk >= this.sensitivity) {
+            this.predictions++;
+            const sig = JSON.stringify(args, Object.keys(args).sort());
+            const key = `${toolName}::${simpleHash(sig).slice(0, 8)}`;
+            let reason = `High risk (${(risk * 100).toFixed(0)}%). Previous failures detected.`;
+            if (this.patterns.has(key)) {
+                const samples = this.patterns.get(key).errorSamples;
+                if (samples.length > 0) {
+                    reason += ` Example: ${samples[0]}`;
+                }
+            }
+            return [true, risk, reason];
+        }
+        return [false, risk, ''];
+    }
+    recordPredictionOutcome(blocked, succeeded) {
+        if (blocked) {
+            this.blockedCalls++;
+            this.falsePositives++;
+        }
+        else {
+            this.allowedCalls++;
+            if (succeeded)
+                this.correctPredictions++;
+        }
+    }
+    get accuracy() {
+        const total = this.correctPredictions + this.falsePositives;
+        return total === 0 ? 1 : this.correctPredictions / total;
+    }
+    get stats() {
+        return {
+            name: this.name,
+            sensitivity: this.sensitivity,
+            patternsLearned: this.totalPatterns,
+            predictionsMade: this.predictions,
+            blockedCalls: this.blockedCalls,
+            allowedCalls: this.allowedCalls,
+            accuracy: `${(this.accuracy * 100).toFixed(1)}%`,
+            historySize: this.callHistory.length,
+            riskThreshold: this.sensitivity,
+        };
+    }
+    get riskReport() {
+        const lines = [
+            `🛡 ProactiveGuard: ${this.name}`,
+            `   Patterns: ${this.totalPatterns} | Blocked: ${this.blockedCalls} | Acc: ${(this.accuracy * 100).toFixed(1)}%`,
+        ];
+        if (this.patterns.size > 0) {
+            const sorted = [...this.patterns.values()]
+                .sort((a, b) => b.failureCount - a.failureCount)
+                .slice(0, 5);
+            lines.push('   Top Risk Patterns:');
+            for (const p of sorted) {
+                const sample = p.errorSamples[0] ?? '';
+                lines.push(`     ⚠ ${p.toolName} (×${p.failureCount}) ${sample.slice(0, 60)}`);
+            }
+        }
+        return lines.join('\n');
+    }
+}
+exports.ProactiveGuard = ProactiveGuard;

package/dist/schema-hub.d.ts

@@ -0,0 +1,64 @@
+/**
+ * SchemaHub — Community Schema Registry
+ * v0.4.0: Community-driven schema ecosystem for agent tool validation.
+ *
+ * Philosophy:
+ *   1. Low friction — one TypeScript interface = one schema
+ *   2. Offline/online — local cache + remote hub
+ *   3. Versioned — semantic versions for every schema
+ *   4. Discoverable — search by category, tags, author
+ */
+export interface SchemaMeta {
+    name: string;
+    version: string;
+    author: string;
+    category: string;
+    tags: string[];
+    description: string;
+    source: 'local' | 'remote';
+    downloads: number;
+    rating: number;
+}
+export declare const CATEGORIES: string[];
+export interface ValidationError {
+    field: string;
+    message: string;
+}
+export declare function validateSchema(schemaName: string, data: unknown): {
+    valid: boolean;
+    errors: ValidationError[];
+};
+interface SchemaDef {
+    fields: Record<string, Record<string, unknown>>;
+}
+export declare const BUILTIN_SCHEMAS: Record<string, SchemaDef>;
+export declare const BUILTIN_META: Record<string, SchemaMeta>;
+export declare class SchemaHub {
+    private schemas;
+    private metas;
+    constructor(schemasDir?: string);
+    /** Register a schema definition with optional metadata */
+    register(name: string, schemaDef: SchemaDef, meta?: Partial<SchemaMeta>): void;
+    private registerBuiltins;
+    get(name: string): SchemaDef | undefined;
+    getMeta(name: string): SchemaMeta | undefined;
+    get available(): string[];
+    get categories(): string[];
+    search(options?: {
+        query?: string;
+        category?: string;
+        tags?: string[];
+        author?: string;
+    }): SchemaMeta[];
+    listByCategory(): Record<string, SchemaMeta[]>;
+    importDir(dirPath: string): number;
+    exportJSON(filePath: string): void;
+    exportMetaJSON(filePath: string): void;
+    validate(name: string, data: unknown): {
+        valid: boolean;
+        errors: ValidationError[];
+    };
+    get stats(): Record<string, unknown>;
+    toString(): string;
+}
+export {};