opc-agent 1.4.0 → 2.0.1

package/dist/schema/oad.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OADSchema = exports.SpecSchema = exports.StreamingSchema = exports.RoomSchema = exports.MetadataSchema = exports.MarketplaceSchema = exports.ProviderSchema = exports.DTVSchema = exports.TrustLevel = exports.MemorySchema = exports.LongTermMemorySchema = exports.ChannelSchema = exports.AuthSchema = exports.PluginRefSchema = exports.HITLSchema = exports.WebhookSchema = exports.VoiceSchema = exports.WorkflowSchema = exports.WorkflowStepSchema = exports.SkillRefSchema = void 0;
+exports.OADSchema = exports.SpecSchema = exports.ProtocolsSchema = exports.AGUIProtocolSchema = exports.TelemetrySchema = exports.ToolsSchema = exports.MCPServeSchema = exports.MCPServerSchema = exports.StreamingSchema = exports.RoomSchema = exports.MetadataSchema = exports.MarketplaceSchema = exports.ProviderSchema = exports.DTVSchema = exports.TrustLevel = exports.MemorySchema = exports.LongTermMemorySchema = exports.ChannelSchema = exports.AuthSchema = exports.PluginRefSchema = exports.HITLSchema = exports.WebhookSchema = exports.VoiceSchema = exports.WorkflowSchema = exports.WorkflowStepSchema = exports.SkillRefSchema = void 0;
 const zod_1 = require("zod");
 // ─── OAD Schema v1 ───────────────────────────────────────────
 exports.SkillRefSchema = zod_1.z.object({
@@ -53,14 +53,20 @@ exports.AuthSchema = zod_1.z.object({
     sessionIsolation: zod_1.z.boolean().default(true),
 });
 exports.ChannelSchema = zod_1.z.object({
-    type: zod_1.z.enum(['web', 'websocket', 'telegram', 'cli', 'voice', 'webhook']),
+    type: zod_1.z.enum(['web', 'websocket', 'telegram', 'cli', 'voice', 'webhook', 'wechat', 'feishu', 'email', 'slack', 'discord']),
     port: zod_1.z.number().optional(),
     config: zod_1.z.record(zod_1.z.unknown()).optional(),
 });
 exports.LongTermMemorySchema = zod_1.z.object({
     provider: zod_1.z.enum(['in-memory', 'deepbrain']).default('in-memory'),
     collection: zod_1.z.string().optional(),
-    config: zod_1.z.record(zod_1.z.unknown()).optional(),
+    config: zod_1.z.object({
+        database: zod_1.z.string().optional(),
+        embeddingProvider: zod_1.z.string().optional(),
+        autoLearn: zod_1.z.boolean().optional(),
+        autoRecall: zod_1.z.boolean().optional(),
+        evolveInterval: zod_1.z.number().optional(),
+    }).passthrough().optional(),
 });
 exports.MemorySchema = zod_1.z.object({
     shortTerm: zod_1.z.boolean().default(true),
@@ -103,6 +109,41 @@ exports.StreamingSchema = zod_1.z.object({
     enabled: zod_1.z.boolean().default(false),
     chunkSize: zod_1.z.number().optional(),
 });
+exports.MCPServerSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    command: zod_1.z.string(),
+    args: zod_1.z.array(zod_1.z.string()).optional(),
+    env: zod_1.z.record(zod_1.z.string()).optional(),
+});
+exports.MCPServeSchema = zod_1.z.object({
+    enabled: zod_1.z.boolean().default(false),
+    mode: zod_1.z.enum(['stdio', 'http']).default('stdio'),
+    port: zod_1.z.number().default(3002),
+    exposedTools: zod_1.z.array(zod_1.z.string()).optional(),
+});
+exports.ToolsSchema = zod_1.z.object({
+    builtin: zod_1.z.array(zod_1.z.string()).optional(),
+    mcp: zod_1.z.array(exports.MCPServerSchema).optional(),
+});
+exports.TelemetrySchema = zod_1.z.object({
+    enabled: zod_1.z.boolean().default(false),
+    exporter: zod_1.z.enum(['console', 'file', 'otlp']).default('console'),
+    endpoint: zod_1.z.string().optional(),
+    filePath: zod_1.z.string().optional(),
+    maxSpans: zod_1.z.number().optional(),
+});
+exports.AGUIProtocolSchema = zod_1.z.object({
+    enabled: zod_1.z.boolean().default(false),
+    path: zod_1.z.string().default('/agui'),
+});
+exports.ProtocolsSchema = zod_1.z.object({
+    a2a: zod_1.z.object({
+        enabled: zod_1.z.boolean().default(false),
+        port: zod_1.z.number().optional(),
+    }).optional(),
+    agui: exports.AGUIProtocolSchema.optional(),
+    mcp: exports.MCPServeSchema.optional(),
+});
 exports.SpecSchema = zod_1.z.object({
     provider: exports.ProviderSchema.optional(),
     model: zod_1.z.string().default('deepseek-chat'),
@@ -110,6 +151,7 @@ exports.SpecSchema = zod_1.z.object({
     skills: zod_1.z.array(exports.SkillRefSchema).default([]),
     channels: zod_1.z.array(exports.ChannelSchema).default([]),
     memory: exports.MemorySchema.optional(),
+    tools: exports.ToolsSchema.optional(),
     dtv: exports.DTVSchema.optional(),
     room: exports.RoomSchema.optional(),
     streaming: zod_1.z.union([zod_1.z.boolean(), exports.StreamingSchema]).default(false),
@@ -119,6 +161,8 @@ exports.SpecSchema = zod_1.z.object({
     webhook: exports.WebhookSchema.optional(),
     hitl: exports.HITLSchema.optional(),
     auth: exports.AuthSchema.optional(),
+    telemetry: exports.TelemetrySchema.optional(),
+    protocols: exports.ProtocolsSchema.optional(),
     plugins: zod_1.z.array(exports.PluginRefSchema).optional(),
 });
 exports.OADSchema = zod_1.z.object({

package/dist/security/approval.d.ts

@@ -0,0 +1,36 @@
+export type ApprovalPolicy = 'always' | 'dangerous' | 'never';
+export interface ApprovalRequest {
+    id: string;
+    type: 'shell' | 'file_write' | 'file_delete' | 'network' | 'plugin';
+    command: string;
+    description: string;
+    requestedAt: Date;
+    status: 'pending' | 'approved' | 'denied';
+    approvedBy?: string;
+}
+export declare class ApprovalManager {
+    private policy;
+    private pendingApprovals;
+    private allowlist;
+    private blocklist;
+    private static readonly DANGEROUS_PATTERNS;
+    constructor(policy?: ApprovalPolicy);
+    getPolicy(): ApprovalPolicy;
+    setPolicy(policy: ApprovalPolicy): void;
+    needsApproval(type: string, command: string): boolean;
+    private isDangerous;
+    private isAllowed;
+    private isBlocked;
+    requestApproval(type: ApprovalRequest['type'], command: string, description: string): ApprovalRequest;
+    approve(id: string, approver: string): void;
+    deny(id: string, approver: string): void;
+    getRequest(id: string): ApprovalRequest | undefined;
+    addToAllowlist(pattern: string): void;
+    removeFromAllowlist(pattern: string): void;
+    addToBlocklist(pattern: string): void;
+    removeFromBlocklist(pattern: string): void;
+    getPending(): ApprovalRequest[];
+    getAllowlist(): string[];
+    getBlocklist(): string[];
+}
+//# sourceMappingURL=approval.d.ts.map

package/dist/security/approval.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApprovalManager = void 0;
+const crypto_1 = require("crypto");
+class ApprovalManager {
+    policy;
+    pendingApprovals = new Map();
+    allowlist = new Set();
+    blocklist = new Set();
+    static DANGEROUS_PATTERNS = [
+        /rm\s+-rf/i, /del\s+\/s/i, /format\s+/i,
+        /DROP\s+TABLE/i, /DELETE\s+FROM/i,
+        /curl.*\|.*sh/i, /wget.*\|.*sh/i,
+        /chmod\s+777/i, /sudo\s+/i,
+        /npm\s+publish/i,
+    ];
+    constructor(policy = 'dangerous') {
+        this.policy = policy;
+    }
+    getPolicy() {
+        return this.policy;
+    }
+    setPolicy(policy) {
+        this.policy = policy;
+    }
+    needsApproval(type, command) {
+        // Blocklist always needs approval (effectively blocked)
+        if (this.isBlocked(command))
+            return true;
+        // Allowlist never needs approval
+        if (this.isAllowed(command))
+            return false;
+        if (this.policy === 'never')
+            return false;
+        if (this.policy === 'always')
+            return true;
+        // 'dangerous'
+        return this.isDangerous(type, command);
+    }
+    isDangerous(_type, command) {
+        return ApprovalManager.DANGEROUS_PATTERNS.some(p => p.test(command));
+    }
+    isAllowed(command) {
+        for (const pattern of this.allowlist) {
+            if (command.includes(pattern))
+                return true;
+        }
+        return false;
+    }
+    isBlocked(command) {
+        for (const pattern of this.blocklist) {
+            if (command.includes(pattern))
+                return true;
+        }
+        return false;
+    }
+    requestApproval(type, command, description) {
+        const request = {
+            id: (0, crypto_1.randomUUID)(),
+            type,
+            command,
+            description,
+            requestedAt: new Date(),
+            status: 'pending',
+        };
+        this.pendingApprovals.set(request.id, request);
+        return request;
+    }
+    approve(id, approver) {
+        const req = this.pendingApprovals.get(id);
+        if (!req)
+            throw new Error(`Approval request ${id} not found`);
+        if (req.status !== 'pending')
+            throw new Error(`Request ${id} is already ${req.status}`);
+        req.status = 'approved';
+        req.approvedBy = approver;
+    }
+    deny(id, approver) {
+        const req = this.pendingApprovals.get(id);
+        if (!req)
+            throw new Error(`Approval request ${id} not found`);
+        if (req.status !== 'pending')
+            throw new Error(`Request ${id} is already ${req.status}`);
+        req.status = 'denied';
+        req.approvedBy = approver;
+    }
+    getRequest(id) {
+        return this.pendingApprovals.get(id);
+    }
+    addToAllowlist(pattern) {
+        this.allowlist.add(pattern);
+    }
+    removeFromAllowlist(pattern) {
+        this.allowlist.delete(pattern);
+    }
+    addToBlocklist(pattern) {
+        this.blocklist.add(pattern);
+    }
+    removeFromBlocklist(pattern) {
+        this.blocklist.delete(pattern);
+    }
+    getPending() {
+        return Array.from(this.pendingApprovals.values()).filter(r => r.status === 'pending');
+    }
+    getAllowlist() {
+        return Array.from(this.allowlist);
+    }
+    getBlocklist() {
+        return Array.from(this.blocklist);
+    }
+}
+exports.ApprovalManager = ApprovalManager;
+//# sourceMappingURL=approval.js.map

package/dist/security/index.d.ts

@@ -0,0 +1,4 @@
+export { ApprovalManager } from './approval';
+export type { ApprovalPolicy, ApprovalRequest } from './approval';
+export { KeyManager } from './keys';
+//# sourceMappingURL=index.d.ts.map

package/dist/security/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyManager = exports.ApprovalManager = void 0;
+var approval_1 = require("./approval");
+Object.defineProperty(exports, "ApprovalManager", { enumerable: true, get: function () { return approval_1.ApprovalManager; } });
+var keys_1 = require("./keys");
+Object.defineProperty(exports, "KeyManager", { enumerable: true, get: function () { return keys_1.KeyManager; } });
+//# sourceMappingURL=index.js.map

package/dist/security/keys.d.ts

@@ -0,0 +1,16 @@
+export declare class KeyManager {
+    private keys;
+    private keyFile;
+    private secret;
+    constructor(keyFile?: string);
+    private deriveSecret;
+    set(name: string, value: string): void;
+    get(name: string): string | undefined;
+    delete(name: string): boolean;
+    list(): string[];
+    private load;
+    private save;
+    private encode;
+    private decode;
+}
+//# sourceMappingURL=keys.d.ts.map

package/dist/security/keys.js

@@ -0,0 +1,117 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const os = __importStar(require("os"));
+class KeyManager {
+    keys = new Map();
+    keyFile;
+    secret;
+    constructor(keyFile = '.opc/keys.json') {
+        this.keyFile = path.resolve(keyFile);
+        this.secret = this.deriveSecret();
+        this.load();
+    }
+    deriveSecret() {
+        // Derive a key from machine-specific info (hostname + homedir)
+        const machineId = `${os.hostname()}:${os.homedir()}:opc-agent-keys`;
+        return crypto.createHash('sha256').update(machineId).digest();
+    }
+    set(name, value) {
+        this.keys.set(name, value);
+        this.save();
+    }
+    get(name) {
+        return this.keys.get(name);
+    }
+    delete(name) {
+        const result = this.keys.delete(name);
+        if (result)
+            this.save();
+        return result;
+    }
+    list() {
+        return Array.from(this.keys.keys());
+    }
+    load() {
+        try {
+            if (fs.existsSync(this.keyFile)) {
+                const data = JSON.parse(fs.readFileSync(this.keyFile, 'utf-8'));
+                for (const [name, encoded] of Object.entries(data)) {
+                    try {
+                        this.keys.set(name, this.decode(encoded));
+                    }
+                    catch {
+                        // Skip corrupted entries
+                    }
+                }
+            }
+        }
+        catch {
+            // File doesn't exist or is corrupted — start fresh
+        }
+    }
+    save() {
+        const dir = path.dirname(this.keyFile);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        const data = {};
+        for (const [name, value] of this.keys) {
+            data[name] = this.encode(value);
+        }
+        fs.writeFileSync(this.keyFile, JSON.stringify(data, null, 2), 'utf-8');
+    }
+    encode(value) {
+        const iv = crypto.randomBytes(16);
+        const cipher = crypto.createCipheriv('aes-256-cbc', this.secret, iv);
+        let encrypted = cipher.update(value, 'utf-8', 'hex');
+        encrypted += cipher.final('hex');
+        return iv.toString('hex') + ':' + encrypted;
+    }
+    decode(encoded) {
+        const [ivHex, encrypted] = encoded.split(':');
+        const iv = Buffer.from(ivHex, 'hex');
+        const decipher = crypto.createDecipheriv('aes-256-cbc', this.secret, iv);
+        let decrypted = decipher.update(encrypted, 'hex', 'utf-8');
+        decrypted += decipher.final('utf-8');
+        return decrypted;
+    }
+}
+exports.KeyManager = KeyManager;
+//# sourceMappingURL=keys.js.map

package/dist/skills/auto-learn.d.ts

@@ -0,0 +1,28 @@
+import type { Message } from '../core/types';
+import type { LLMProvider } from '../providers';
+export interface LearnedSkill {
+    name: string;
+    description: string;
+    trigger: string;
+    instructions: string;
+    examples: string[];
+    createdAt: Date;
+    usageCount: number;
+    lastUsed?: Date;
+    version: number;
+}
+export declare class SkillLearner {
+    private skillsDir;
+    private skills;
+    private loaded;
+    constructor(skillsDir: string);
+    analyzeForSkillCreation(conversation: Message[], provider: LLMProvider): Promise<LearnedSkill | null>;
+    saveSkill(skill: LearnedSkill): Promise<void>;
+    loadLearnedSkills(): Promise<LearnedSkill[]>;
+    matchSkill(message: string): LearnedSkill | null;
+    improveSkill(skill: LearnedSkill, conversation: Message[], provider: LLMProvider): Promise<void>;
+    getSkills(): LearnedSkill[];
+}
+export declare function skillToMarkdown(skill: LearnedSkill): string;
+export declare function parseSkillMarkdown(content: string): LearnedSkill | null;
+//# sourceMappingURL=auto-learn.d.ts.map

package/dist/skills/auto-learn.js

@@ -0,0 +1,257 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillLearner = void 0;
+exports.skillToMarkdown = skillToMarkdown;
+exports.parseSkillMarkdown = parseSkillMarkdown;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const SKILL_EXTRACTION_PROMPT = `Analyze this conversation and determine if it represents a repeatable task that should be saved as a reusable skill.
+
+Criteria for creating a skill:
+1. The task is specific and well-defined
+2. It could reasonably happen again
+3. The solution has clear steps
+
+If yes, extract:
+- name: short kebab-case name
+- description: one-line description
+- trigger: regex pattern or keywords that would identify this task
+- instructions: step-by-step instructions to complete the task
+- examples: 2-3 example user inputs that would trigger this skill
+
+If this is just casual chat or a one-off question, return null.
+
+Respond in JSON format only: { "shouldCreate": boolean, "skill": { "name": string, "description": string, "trigger": string, "instructions": string, "examples": string[] } | null }
+
+Conversation:
+`;
+const SKILL_IMPROVEMENT_PROMPT = `This skill was just used. Based on the outcome, suggest improvements:
+
+Current skill:
+`;
+const SKILL_IMPROVEMENT_SUFFIX = `
+
+Respond in JSON only: { "shouldImprove": boolean, "improvements": { "instructions"?: string, "trigger"?: string, "examples"?: string[] } | null }`;
+class SkillLearner {
+    skillsDir;
+    skills = [];
+    loaded = false;
+    constructor(skillsDir) {
+        this.skillsDir = skillsDir;
+    }
+    async analyzeForSkillCreation(conversation, provider) {
+        const conversationText = conversation
+            .map((m) => `${m.role}: ${m.content}`)
+            .join('\n');
+        const prompt = SKILL_EXTRACTION_PROMPT + conversationText;
+        try {
+            const response = await provider.chat([{ id: 'analysis', role: 'user', content: prompt, timestamp: Date.now() }], 'You are a skill extraction assistant. Respond only with valid JSON.');
+            const json = extractJson(response);
+            if (!json || !json.shouldCreate || !json.skill)
+                return null;
+            const skill = {
+                name: json.skill.name,
+                description: json.skill.description,
+                trigger: json.skill.trigger,
+                instructions: json.skill.instructions,
+                examples: json.skill.examples || [],
+                createdAt: new Date(),
+                usageCount: 0,
+                version: 1,
+            };
+            return skill;
+        }
+        catch {
+            return null;
+        }
+    }
+    async saveSkill(skill) {
+        fs.mkdirSync(this.skillsDir, { recursive: true });
+        const filePath = path.join(this.skillsDir, `${skill.name}.md`);
+        fs.writeFileSync(filePath, skillToMarkdown(skill), 'utf-8');
+        // Update cache
+        const idx = this.skills.findIndex((s) => s.name === skill.name);
+        if (idx >= 0) {
+            this.skills[idx] = skill;
+        }
+        else {
+            this.skills.push(skill);
+        }
+    }
+    async loadLearnedSkills() {
+        if (!fs.existsSync(this.skillsDir))
+            return [];
+        const files = fs.readdirSync(this.skillsDir).filter((f) => f.endsWith('.md'));
+        this.skills = files
+            .map((f) => {
+            try {
+                const content = fs.readFileSync(path.join(this.skillsDir, f), 'utf-8');
+                return parseSkillMarkdown(content);
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((s) => s !== null);
+        this.loaded = true;
+        return this.skills;
+    }
+    matchSkill(message) {
+        if (!this.loaded)
+            return null;
+        for (const skill of this.skills) {
+            try {
+                const regex = new RegExp(skill.trigger, 'i');
+                if (regex.test(message))
+                    return skill;
+            }
+            catch {
+                // Fallback: keyword matching — split on common separators, strip non-word chars
+                const keywords = skill.trigger.split(/[\s,;|]+/).map(k => k.replace(/[^\w-]/g, '').toLowerCase()).filter(k => k.length > 2);
+                const lower = message.toLowerCase();
+                if (keywords.some((kw) => lower.includes(kw)))
+                    return skill;
+            }
+        }
+        return null;
+    }
+    async improveSkill(skill, conversation, provider) {
+        const conversationText = conversation
+            .map((m) => `${m.role}: ${m.content}`)
+            .join('\n');
+        const prompt = SKILL_IMPROVEMENT_PROMPT +
+            skillToMarkdown(skill) +
+            '\n\nConversation where it was used:\n' +
+            conversationText +
+            SKILL_IMPROVEMENT_SUFFIX;
+        try {
+            const response = await provider.chat([{ id: 'improve', role: 'user', content: prompt, timestamp: Date.now() }], 'You are a skill improvement assistant. Respond only with valid JSON.');
+            const json = extractJson(response);
+            if (!json || !json.shouldImprove || !json.improvements)
+                return;
+            const { improvements } = json;
+            if (improvements.instructions)
+                skill.instructions = improvements.instructions;
+            if (improvements.trigger)
+                skill.trigger = improvements.trigger;
+            if (improvements.examples)
+                skill.examples = [...skill.examples, ...improvements.examples];
+            skill.version++;
+            await this.saveSkill(skill);
+        }
+        catch {
+            // Silently fail — improvement is best-effort
+        }
+    }
+    getSkills() {
+        return [...this.skills];
+    }
+}
+exports.SkillLearner = SkillLearner;
+// ─── Helpers ────────────────────────────────────────────────
+function extractJson(text) {
+    // Try to extract JSON from response (may be wrapped in markdown code block)
+    const match = text.match(/\{[\s\S]*\}/);
+    if (!match)
+        return null;
+    try {
+        return JSON.parse(match[0]);
+    }
+    catch {
+        return null;
+    }
+}
+function skillToMarkdown(skill) {
+    const lines = [
+        `# Skill: ${skill.name}`,
+        '',
+        '## Description',
+        skill.description,
+        '',
+        '## Trigger',
+        `Pattern: ${skill.trigger}`,
+        '',
+        '## Instructions',
+        skill.instructions,
+        '',
+        '## Examples',
+        ...skill.examples.map((e) => `- "${e}"`),
+        '',
+        '## Metadata',
+        `- Created: ${skill.createdAt.toISOString()}`,
+        `- Version: ${skill.version}`,
+        `- Usage Count: ${skill.usageCount}`,
+        `- Last Used: ${skill.lastUsed?.toISOString() ?? 'never'}`,
+        '',
+    ];
+    return lines.join('\n');
+}
+function parseSkillMarkdown(content) {
+    const nameMatch = content.match(/^# Skill:\s*(.+)$/m);
+    if (!nameMatch)
+        return null;
+    const section = (heading) => {
+        const re = new RegExp(`## ${heading}\\s*\\n([\\s\\S]*?)(?=\\n## |$)`);
+        const m = content.match(re);
+        return m ? m[1].trim() : '';
+    };
+    const description = section('Description');
+    const triggerLine = section('Trigger');
+    const trigger = triggerLine.replace(/^Pattern:\s*/i, '').trim();
+    const instructions = section('Instructions');
+    const examplesRaw = section('Examples');
+    const examples = examplesRaw
+        .split('\n')
+        .map((l) => l.replace(/^-\s*"?|"?\s*$/g, '').trim())
+        .filter(Boolean);
+    const metadata = section('Metadata');
+    const getMeta = (key) => {
+        const m = metadata.match(new RegExp(`- ${key}:\\s*(.+)`, 'i'));
+        return m ? m[1].trim() : '';
+    };
+    return {
+        name: nameMatch[1].trim(),
+        description,
+        trigger,
+        instructions,
+        examples,
+        createdAt: new Date(getMeta('Created') || Date.now()),
+        version: parseInt(getMeta('Version') || '1', 10),
+        usageCount: parseInt(getMeta('Usage Count') || '0', 10),
+        lastUsed: getMeta('Last Used') !== 'never' ? new Date(getMeta('Last Used')) : undefined,
+    };
+}
+//# sourceMappingURL=auto-learn.js.map