pigpig-agent 1.0.0

package/dist/plugins/supabase-plugin.js

@@ -0,0 +1,111 @@
+export const supabasePlugin = {
+    name: 'supabase',
+    version: '1.0.0',
+    description: '提供 Supabase 数据库操作能力（query / insert / list_tables）',
+    config: {
+        supabaseUrl: '${SUPABASE_URL}',
+        supabaseKey: '${SUPABASE_KEY}',
+    },
+    activate(api) {
+        const config = api.getConfig();
+        const url = config.supabaseUrl;
+        const key = config.supabaseKey;
+        if (!url || !key) {
+            api.log('未配置 SUPABASE_URL / SUPABASE_KEY，使用 Mock 模式');
+        }
+        api.registerTools([
+            {
+                name: 'list_tables',
+                description: '列出数据库中所有表',
+                parameters: { type: 'object', properties: {}, required: [] },
+                isConcurrencySafe: true,
+                isReadOnly: true,
+                execute: async () => {
+                    if (!url) {
+                        return JSON.stringify({
+                            tables: ['users', 'posts', 'comments', 'sessions'],
+                            note: 'Mock 模式 — 配置 SUPABASE_URL 和 SUPABASE_KEY 连接真实数据库',
+                        });
+                    }
+                    return `连接 ${url} 查询表列表...（真实实现会调用 Supabase API）`;
+                },
+            },
+            {
+                name: 'query',
+                description: '查询指定表的数据，支持 select / where / limit',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        table: { type: 'string', description: '表名' },
+                        select: { type: 'string', description: '查询字段，默认 *' },
+                        where: { type: 'string', description: '过滤条件，如 status=active' },
+                        limit: { type: 'number', description: '返回条数限制，默认 10' },
+                    },
+                    required: ['table'],
+                },
+                isConcurrencySafe: true,
+                isReadOnly: true,
+                execute: async (input) => {
+                    const { table, select = '*', where, limit = 10 } = input;
+                    if (!url) {
+                        const mockData = {
+                            users: [
+                                { id: 1, name: '张三', email: 'zhang@example.com', role: 'admin' },
+                                { id: 2, name: '李四', email: 'li@example.com', role: 'user' },
+                                { id: 3, name: '王五', email: 'wang@example.com', role: 'user' },
+                            ],
+                            posts: [
+                                { id: 1, title: 'Agent 开发入门', author_id: 1, status: 'published' },
+                                { id: 2, title: 'Plugin 架构设计', author_id: 1, status: 'draft' },
+                            ],
+                            comments: [
+                                { id: 1, post_id: 1, user_id: 2, content: '写得不错！' },
+                            ],
+                            sessions: [
+                                { id: 'sess-001', user_id: 1, created_at: '2026-05-01T10:00:00Z' },
+                            ],
+                        };
+                        const rows = mockData[table] || [];
+                        let filtered = rows;
+                        if (where) {
+                            const [field, value] = where.split('=');
+                            filtered = rows.filter(r => String(r[field]) === value);
+                        }
+                        return JSON.stringify({ table, rows: filtered.slice(0, limit), total: filtered.length });
+                    }
+                    return `SELECT ${select} FROM ${table}${where ? ` WHERE ${where}` : ''} LIMIT ${limit}`;
+                },
+            },
+            {
+                name: 'insert',
+                description: '向指定表插入一条记录',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        table: { type: 'string', description: '表名' },
+                        data: { type: 'object', description: '要插入的数据' },
+                    },
+                    required: ['table', 'data'],
+                },
+                isConcurrencySafe: false,
+                isReadOnly: false,
+                execute: async (input) => {
+                    const { table, data } = input;
+                    if (!url) {
+                        return JSON.stringify({
+                            success: true,
+                            table,
+                            inserted: { id: Math.floor(Math.random() * 1000), ...data },
+                            note: 'Mock 模式',
+                        });
+                    }
+                    return `INSERT INTO ${table} — ${JSON.stringify(data)}`;
+                },
+            },
+        ]);
+        api.log(`已注册 3 个工具（list_tables / query / insert）`);
+    },
+    destroy() {
+        console.log('  [plugin:supabase] 连接已释放');
+    },
+};

package/dist/plugins/types.js

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

package/dist/rag/chunker.js

@@ -0,0 +1,54 @@
+const TARGET_TOKEN = 256; // 目标token数
+const CHARS_PER_TOKEN = 4; // 每个token的字符数
+const TARGET_CHARS = TARGET_TOKEN * CHARS_PER_TOKEN; // 目标字符数
+export function chunkDocument(source, text) {
+    const paragraphs = text.split(/\n{2,}/); // ['段落1', '段落2', ...]
+    const chunks = [];
+    let current = '';
+    let idx = 0;
+    for (const para of paragraphs) {
+        const trimmed = para.trim();
+        if (trimmed.length === 0)
+            continue;
+        // 缓冲区 + 新段落 > 目标字符数，先将缓冲区中的内容存起来
+        if (current.length + trimmed.length + 2 > TARGET_CHARS && current.length > 0) { // 这一段到了最大字符数
+            chunks.push(makeChunk(source, current.trim(), idx++));
+            current = '';
+        }
+        // 单个段落 > 目标字符数，按照句子分割
+        if (trimmed.length > TARGET_CHARS) { // 超长
+            if (current.length > 0) {
+                chunks.push(makeChunk(source, current.trim(), idx++));
+                current = '';
+            }
+            const sentences = trimmed.split(/(?<=[。！？.!?])\s*/);
+            let sentBuf = ''; // 句子缓冲区
+            for (const sent of sentences) {
+                if (sentBuf.length + sent.length + 1 > TARGET_CHARS && sentBuf.length > 0) {
+                    chunks.push(makeChunk(source, sentBuf.trim(), idx++));
+                    sentBuf = '';
+                }
+                sentBuf += (sentBuf ? ' ' : '') + sent;
+            }
+            if (sentBuf.trim()) {
+                current += sentBuf.trim();
+            }
+        }
+        else {
+            current += (current ? '\n\n' : '') + trimmed;
+        }
+    }
+    if (current.trim()) {
+        chunks.push(makeChunk(source, current.trim(), idx++));
+    }
+    return chunks;
+}
+function makeChunk(source, text, index) {
+    return {
+        id: `${source}#${index}`,
+        text,
+        source,
+        index,
+        tokenEstimate: Math.ceil(text.length / CHARS_PER_TOKEN),
+    };
+}

package/dist/rag/embedder.js

@@ -0,0 +1,53 @@
+const DIMS = 128; // 128维度
+export function createDashScopeEmbedder(apiKey) {
+    return async (texts) => {
+        const resp = await fetch('https://dashscope.aliyuncs.com/compatible-mode/v1/embeddings', {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                model: 'text-embedding-v3',
+                input: texts,
+                dimensions: DIMS,
+            }),
+        });
+        const data = await resp.json();
+        return data.data.map((d) => d.embedding);
+    };
+}
+// 相同的文本没必要重复做向量处理
+const embedCache = new Map();
+export async function embed(fn, texts) {
+    const results = new Array(texts.length);
+    const uncached = [];
+    for (let i = 0; i < texts.length; i++) {
+        const cached = embedCache.get(texts[i]);
+        if (cached) {
+            results[i] = cached;
+        }
+        else {
+            uncached.push({ idx: i, text: texts[i] });
+        }
+    }
+    if (uncached.length > 0) {
+        const vectors = await fn(uncached.map(u => u.text)); // 批量处理未缓存的文本
+        for (let i = 0; i < uncached.length; i++) {
+            results[uncached[i].idx] = vectors[i];
+            embedCache.set(uncached[i].text, vectors[i]);
+        }
+    }
+    return results;
+}
+// 计算向量之间的余弦相似度   ---  两个向量”有多像“
+export function cosineSimilarity(a, b) {
+    let dot = 0, normA = 0, normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dot += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    return dot / (Math.sqrt(normA) * Math.sqrt(normB) || 1);
+}
+export { DIMS };

package/dist/rag/search.js

@@ -0,0 +1,123 @@
+import { cosineSimilarity, embed } from "./embedder.js";
+const VECTOR_WEIGHT = 0.7;
+const KEYWORD_WEIGHT = 0.3;
+const CANIDATE_MULTIPLIER = 4; // top-k 候选数量
+const MMR_LAMBDA = 0.7; // MMR 算法的参数，70% 相关性 30% 多样性
+export async function hybridSearch(// 混合检索
+store, embedFn, query, topK = 5) {
+    const all = store.getAll(); // 获取所有的向量数据
+    const candidateCount = Math.min(topK * CANIDATE_MULTIPLIER, all.length);
+    // 路径一：向量检索
+    const [queryVec] = await embed(embedFn, [query]); // 先将查询语句转成向量
+    const vectorResults = all
+        .map(chunk => ({ chunk, score: cosineSimilarity(queryVec, chunk.embedding) }))
+        .sort((a, b) => b.score - a.score)
+        .slice(0, candidateCount);
+    // 路径二：关键词检索   (BM25 算法)
+    const queryTerms = tokenize(query); // 对查询语句进行分词
+    const docCount = all.length; // 文档数量
+    const keywordResults = all
+        .map(chunk => ({ chunk, score: bm25Score(queryTerms, chunk.text, docCount, all) }))
+        .sort((a, b) => b.score - a.score)
+        .slice(0, candidateCount);
+    // 归一化：不是两种分数的和
+    const vecNorm = normalizeMinMax(vectorResults.map(r => r.score));
+    const kwNorm = normalizeViaSigmoid(keywordResults.map(r => r.score)); // 因为BM25 得到的分数可能是负数也可能很大
+    // 合并结果
+    const candidates = new Map();
+    for (let i = 0; i < vectorResults.length; i++) {
+        const id = vectorResults[i].chunk.id;
+        candidates.set(id, {
+            chunk: vectorResults[i].chunk,
+            score: vecNorm[i] * VECTOR_WEIGHT,
+            vectorScore: vecNorm[i],
+            keywordScore: 0,
+        });
+    }
+    for (let i = 0; i < keywordResults.length; i++) {
+        const id = keywordResults[i].chunk.id;
+        const existing = candidates.get(id);
+        if (existing) {
+            existing.keywordScore = kwNorm[i];
+            existing.score += kwNorm[i] * KEYWORD_WEIGHT;
+        }
+        else {
+            candidates.set(id, {
+                chunk: keywordResults[i].chunk,
+                score: kwNorm[i] * KEYWORD_WEIGHT,
+                vectorScore: 0,
+                keywordScore: kwNorm[i],
+            });
+        }
+    }
+    // 排序
+    const sorted = [...candidates.values()].sort((a, b) => b.score - a.score);
+    // 处理数据的相关性和多样性  (防止搜到的数据有重复)
+    return mmrSelect(sorted, topK);
+}
+// BM25 算文本的匹配度
+function tokenize(text) {
+    return text.toLowerCase()
+        .replace(/[^\w一-鿿]+/g, ' ')
+        .split(/\s+/)
+        .filter(t => t.length > 1);
+}
+function bm25Score(queryTerms, docText, N, allDocs) {
+    const k1 = 1.2;
+    const b = 0.75;
+    const docTokens = tokenize(docText);
+    const avgDl = allDocs.reduce((s, d) => s + tokenize(d.text).length, 0) / (N || 1);
+    const dl = docTokens.length;
+    let score = 0;
+    for (const term of queryTerms) {
+        const tf = docTokens.filter(t => t === term).length;
+        const df = allDocs.filter(d => tokenize(d.text).includes(term)).length;
+        const idf = Math.log((N - df + 0.5) / (df + 0.5) + 1);
+        const tfNorm = (tf * (k1 + 1)) / (tf + k1 * (1 - b + b * (dl / avgDl)));
+        score += idf * tfNorm;
+    }
+    return score;
+}
+// 归一化操作
+function normalizeMinMax(scores) {
+    if (scores.length === 0)
+        return [];
+    const min = Math.min(...scores);
+    const max = Math.max(...scores);
+    const range = max - min || 1;
+    return scores.map(s => (s - min) / range);
+}
+// 计算 sigmoid 函数的值，将分数映射到 (0, 1) 范围内，同时保持分数的相对顺序
+function normalizeViaSigmoid(scores) {
+    return scores.map(s => 1 / (1 + Math.exp(-s)));
+}
+// MMR 去重
+function mmrSelect(results, topK) {
+    if (results.length <= topK)
+        return results;
+    const selected = [results[0]];
+    const remaining = results.slice(1);
+    while (selected.length < topK && remaining.length > 0) {
+        let bestIdx = 0;
+        let bestMmr = -Infinity;
+        for (let i = 0; i < remaining.length; i++) {
+            const relevance = remaining[i].score;
+            const maxSim = Math.max(...selected.map(s => jaccardSimilarity(s.chunk.text, remaining[i].chunk.text)));
+            const mmr = MMR_LAMBDA * relevance - (1 - MMR_LAMBDA) * maxSim;
+            if (mmr > bestMmr) {
+                bestMmr = mmr;
+                bestIdx = i;
+            }
+        }
+        selected.push(remaining[bestIdx]);
+        remaining.splice(bestIdx, 1);
+    }
+    return selected;
+}
+function jaccardSimilarity(a, b) {
+    const setA = new Set(tokenize(a));
+    const setB = new Set(tokenize(b));
+    const intersection = [...setA].filter(t => setB.has(t)).length;
+    const union = new Set([...setA, ...setB]).size;
+    return union === 0 ? 0 : intersection / union;
+}

package/dist/rag/sqlite-store.js

@@ -0,0 +1,195 @@
+import Database from 'better-sqlite3';
+import * as sqliteVec from 'sqlite-vec';
+import { embed } from './embedder.js';
+const MMR_LAMBDA = 0.7;
+export class SqliteVectorStore {
+    db;
+    constructor(dbPath = 'knowledge.db') {
+        this.db = new Database(dbPath);
+        sqliteVec.load(this.db); // 加载向量搜索扩展
+        this.createTables();
+    }
+    createTables() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS chunks (
+        id TEXT PRIMARY KEY,
+        text TEXT NOT NULL,
+        source TEXT NOT NULL,
+        chunk_index INTEGER NOT NULL,
+        embedding TEXT NOT NULL,
+        model TEXT NOT NULL DEFAULT 'text-embedding-v3',
+        updated_at INTEGER NOT NULL
+      );
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS chunks_vec USING vec0(
+        id TEXT PRIMARY KEY,
+        embedding FLOAT[128]
+      );
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(
+        text, id UNINDEXED, source UNINDEXED
+      );
+    `);
+    }
+    add(chunk, embedding) {
+        const now = Date.now();
+        // 三表联动写入
+        this.db.prepare(`INSERT OR REPLACE INTO chunks
+      (id, text, source, chunk_index, embedding, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?)`)
+            .run(chunk.id, chunk.text, chunk.source, chunk.index, JSON.stringify(embedding), now);
+        this.db.prepare(`INSERT OR REPLACE INTO chunks_vec (id, embedding)
+      VALUES (?, ?)`)
+            .run(chunk.id, Buffer.from(new Float32Array(embedding).buffer));
+        this.db.prepare(`INSERT OR REPLACE INTO chunks_fts (id, text, source)
+      VALUES (?, ?, ?)`)
+            .run(chunk.id, chunk.text, chunk.source);
+    }
+    addBatch(items) {
+        const tx = this.db.transaction(() => {
+            for (const { chunk, embedding } of items)
+                this.add(chunk, embedding);
+        });
+        tx(); // 事务批量写入，比逐条快很多
+    }
+    vectorSearch(queryEmbedding, topK) {
+        const buf = Buffer.from(new Float32Array(queryEmbedding).buffer);
+        const rows = this.db.prepare(`
+      SELECT v.id, v.distance, c.text, c.source, c.chunk_index, c.embedding
+      FROM chunks_vec v
+      JOIN chunks c ON c.id = v.id
+      WHERE v.embedding MATCH ?
+      ORDER BY v.distance
+      LIMIT ?
+    `).all(buf, topK);
+        return rows.map(r => ({
+            chunk: {
+                id: r.id, text: r.text, source: r.source,
+                index: r.chunk_index,
+                tokenEstimate: Math.ceil(r.text.length / 4),
+                embedding: JSON.parse(r.embedding),
+                addedAt: 0,
+            },
+            score: 1 - r.distance, // cosine distance → similarity
+        }));
+    }
+    keywordSearch(query, topK) {
+        const rows = this.db.prepare(`
+      SELECT f.id, bm25(chunks_fts) AS rank, c.text, c.source, c.chunk_index, c.embedding
+      FROM chunks_fts f
+      JOIN chunks c ON c.id = f.id
+      WHERE chunks_fts MATCH ?
+      ORDER BY rank
+      LIMIT ?
+    `).all(query, topK);
+        return rows.map(r => ({
+            chunk: {
+                id: r.id, text: r.text, source: r.source,
+                index: r.chunk_index,
+                tokenEstimate: Math.ceil(r.text.length / 4),
+                embedding: JSON.parse(r.embedding),
+                addedAt: 0,
+            },
+            score: r.rank < 0 ? -r.rank / (1 - r.rank) : 1 / (1 + r.rank),
+        }));
+    }
+    size() {
+        return this.db.prepare('SELECT COUNT(*) as n FROM chunks').get().n;
+    }
+    clear() {
+        this.db.exec('DELETE FROM chunks; DELETE FROM chunks_vec; DELETE FROM chunks_fts;');
+    }
+    sources() {
+        return this.db.prepare('SELECT DISTINCT source FROM chunks').all().map(r => r.source);
+    }
+    // 混合搜索：直接在 SQLite 层完成向量 + 关键词双路检索
+    async hybridSearch(embedFn, query, topK = 5) {
+        const candidateCount = Math.min(topK * 4, this.size());
+        if (candidateCount === 0)
+            return [];
+        const [queryVec] = await embed(embedFn, [query]);
+        // 路径 1: sqlite-vec 向量搜索
+        const vectorResults = this.vectorSearch(queryVec, candidateCount);
+        // 路径 2: FTS5 关键词搜索
+        const keywordResults = this.keywordSearch(query, candidateCount);
+        // 归一化 + 加权合并
+        const vecScores = normalizeMinMax(vectorResults.map(r => r.score));
+        const kwScores = normalizeMinMax(keywordResults.map(r => r.score));
+        const candidates = new Map();
+        for (let i = 0; i < vectorResults.length; i++) {
+            const id = vectorResults[i].chunk.id;
+            candidates.set(id, {
+                chunk: vectorResults[i].chunk,
+                score: vecScores[i] * 0.7,
+                vectorScore: vecScores[i],
+                keywordScore: 0,
+            });
+        }
+        for (let i = 0; i < keywordResults.length; i++) {
+            const id = keywordResults[i].chunk.id;
+            const existing = candidates.get(id);
+            if (existing) {
+                existing.keywordScore = kwScores[i];
+                existing.score += kwScores[i] * 0.3;
+            }
+            else {
+                candidates.set(id, {
+                    chunk: keywordResults[i].chunk,
+                    score: kwScores[i] * 0.3,
+                    vectorScore: 0,
+                    keywordScore: kwScores[i],
+                });
+            }
+        }
+        const sorted = [...candidates.values()]
+            .sort((a, b) => b.score - a.score);
+        // MMR deduplication
+        return mmrSelect(sorted, topK);
+    }
+}
+// BM25 算文本的匹配度
+function tokenize(text) {
+    return text.toLowerCase()
+        .replace(/[^\w一-鿿]+/g, ' ')
+        .split(/\s+/)
+        .filter(t => t.length > 1);
+}
+// 归一化操作
+function normalizeMinMax(scores) {
+    if (scores.length === 0)
+        return [];
+    const min = Math.min(...scores);
+    const max = Math.max(...scores);
+    const range = max - min || 1;
+    return scores.map(s => (s - min) / range);
+}
+// MMR 去重
+function mmrSelect(results, topK) {
+    if (results.length <= topK)
+        return results;
+    const selected = [results[0]];
+    const remaining = results.slice(1);
+    while (selected.length < topK && remaining.length > 0) {
+        let bestIdx = 0;
+        let bestMmr = -Infinity;
+        for (let i = 0; i < remaining.length; i++) {
+            const relevance = remaining[i].score;
+            const maxSim = Math.max(...selected.map(s => jaccardSimilarity(s.chunk.text, remaining[i].chunk.text)));
+            const mmr = MMR_LAMBDA * relevance - (1 - MMR_LAMBDA) * maxSim;
+            if (mmr > bestMmr) {
+                bestMmr = mmr;
+                bestIdx = i;
+            }
+        }
+        selected.push(remaining[bestIdx]);
+        remaining.splice(bestIdx, 1);
+    }
+    return selected;
+}
+function jaccardSimilarity(a, b) {
+    const setA = new Set(tokenize(a));
+    const setB = new Set(tokenize(b));
+    const intersection = [...setA].filter(t => setB.has(t)).length;
+    const union = new Set([...setA, ...setB]).size;
+    return union === 0 ? 0 : intersection / union;
+}

package/dist/rag/store.js

@@ -0,0 +1,29 @@
+export class VectorStore {
+    chunks = []; // 自己打造的向量数据库
+    add(chunk, embedding) {
+        const existing = this.chunks.findIndex(c => c.id === chunk.id);
+        if (existing >= 0) {
+            this.chunks[existing] = { ...chunk, embedding, addedAt: Date.now() };
+        }
+        else {
+            this.chunks.push({ ...chunk, embedding, addedAt: Date.now() });
+        }
+    }
+    addBatch(items) {
+        for (const { chunk, embedding } of items) {
+            this.add(chunk, embedding);
+        }
+    }
+    getAll() {
+        return this.chunks;
+    }
+    size() {
+        return this.chunks.length;
+    }
+    clear() {
+        this.chunks = [];
+    }
+    sources() {
+        return [...new Set(this.chunks.map(c => c.source))];
+    }
+}

package/dist/security/bash-classifier.js

@@ -0,0 +1,39 @@
+const DANGEROUS_PATTERNS = [
+    { pattern: /\brm\s+(-[a-zA-Z]*f[a-zA-Z]*\s+|.*-rf\b|.*--force)/, reason: '强制删除文件' },
+    { pattern: /\brm\s+-[a-zA-Z]*r/, reason: '递归删除' },
+    { pattern: /\bsudo\b/, reason: '提权操作' },
+    { pattern: /\bmkfs\b/, reason: '格式化磁盘' },
+    { pattern: /\bdd\s+.*of=\/dev\//, reason: '直接写设备' },
+    { pattern: /:\(\)\s*\{.*\|.*&\s*\}/, reason: 'Fork bomb' },
+    { pattern: />\s*\/dev\/sd[a-z]/, reason: '覆写磁盘设备' },
+    { pattern: /\bchmod\s+777\b/, reason: '开放所有权限' },
+    { pattern: /\bcurl\b.*\|\s*(ba)?sh/, reason: '远程脚本执行' },
+    { pattern: /\bwget\b.*\|\s*(ba)?sh/, reason: '远程脚本执行' },
+    { pattern: /\beval\b/, reason: 'eval 动态执行' },
+    { pattern: />\s*\/etc\//, reason: '覆写系统配置' },
+];
+const MODERATE_PATTERNS = [
+    { pattern: /\brm\b/, reason: '删除文件' },
+    { pattern: /\bmv\b/, reason: '移动/重命名文件' },
+    { pattern: /\bchmod\b/, reason: '修改权限' },
+    { pattern: /\bchown\b/, reason: '修改所有者' },
+    { pattern: /\bkill\b/, reason: '终止进程' },
+    { pattern: /\bpkill\b/, reason: '批量终止进程' },
+    { pattern: /\bgit\s+push\b/, reason: 'Git 推送' },
+    { pattern: /\bgit\s+reset\s+--hard\b/, reason: 'Git 硬重置' },
+    { pattern: /\bnpm\s+publish\b/, reason: '发布 npm 包' },
+    { pattern: /\bdocker\s+rm\b/, reason: '删除容器' },
+];
+export function classifyBashCommand(command) {
+    for (const { pattern, reason } of DANGEROUS_PATTERNS) {
+        if (pattern.test(command)) {
+            return { level: 'dangerous', reason };
+        }
+    }
+    for (const { pattern, reason } of MODERATE_PATTERNS) {
+        if (pattern.test(command)) {
+            return { level: 'moderate', reason };
+        }
+    }
+    return { level: 'safe' };
+}

package/dist/security/hook.js

@@ -0,0 +1,53 @@
+export class HookPipeline {
+    preHooks = [];
+    postHooks = [];
+    registerPre(name, fn) {
+        this.preHooks.push({ name, fn });
+    }
+    registerPost(name, fn) {
+        this.postHooks.push({ name, fn });
+    }
+    async runPre(toolName, input) {
+        let currentInput = input;
+        for (const hook of this.preHooks) {
+            try {
+                const result = await hook.fn(toolName, currentInput);
+                if (result.action === 'block') {
+                    console.log(` [hook: ${hook.name}] 拦截 ${toolName}: ${result.reason}`);
+                    return result;
+                }
+                if (result.action === 'modify' && result.modifiedInput !== undefined) {
+                    currentInput = result.modifiedInput;
+                    console.log(` [hook: ${hook.name}] 修改了 ${toolName} 的输入`);
+                }
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.error(` [hook: ${hook.name}] 执行Pre异常: ${msg}`);
+            }
+        }
+        return { action: 'allow' };
+    }
+    async runPost(toolName, input, output) {
+        let currentOutput = output;
+        for (const hook of this.postHooks) {
+            try {
+                const result = await hook.fn(toolName, input, currentOutput);
+                if (result.action === 'modify' && result.modifiedOutput !== undefined) {
+                    currentOutput = result.modifiedOutput;
+                }
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.error(` [hook: ${hook.name}] 执行Post异常: ${msg}`);
+            }
+        }
+        return { action: 'allow', modifiedOutput: currentOutput };
+    }
+    list() {
+        return {
+            pre: this.preHooks.map(hook => hook.name),
+            post: this.postHooks.map(hook => hook.name)
+        };
+    }
+}

package/dist/security/roles.js

@@ -0,0 +1,16 @@
+const TOOL_ACCESS = {
+    owner: { allow: '*', deny: [] }, // 完全访问
+    collaborator: { allow: '*', deny: ['bash'] }, // 自动审批
+    guest: { allow: ['read_file', 'list_directory', 'glob', 'grep', 'rag_search'], deny: [] }, // 手动审批
+};
+export function canUseTool(role, toolName) {
+    const access = TOOL_ACCESS[role];
+    if (access.deny.includes(toolName))
+        return false;
+    if (access.allow === '*')
+        return true;
+    return access.allow.includes(toolName);
+}
+export function filterToolsForRole(toolNames, role) {
+    return toolNames.filter(name => canUseTool(role, name));
+}