@code4bug/jarvis-agent 1.0.2

package/dist/core/hint.js

@@ -0,0 +1,279 @@
+/**
+ * 智能提示生成器
+ *
+ * 根据当前激活的智能体角色 + 项目上下文，调用 LLM 生成一条
+ * 符合角色设定且贴合当前项目的输入提示信息。
+ */
+import fs from 'fs';
+import path from 'path';
+import { getAgent } from '../agents/index.js';
+import { DEFAULT_AGENT } from '../config/constants.js';
+import { loadConfig, getActiveModel } from '../config/loader.js';
+import { getDefaultConfig } from '../services/api/llm.js';
+/** 安全读取 JSON 文件 */
+function readJsonSafe(filePath) {
+    try {
+        if (!fs.existsSync(filePath))
+            return null;
+        return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+/** 采集顶层目录结构（只取第一层，排除 node_modules / .git 等） */
+function getTopLevelStructure(cwd) {
+    const IGNORE = new Set(['node_modules', '.git', '.DS_Store', 'dist', 'build', '.sessions', '__pycache__', '.venv', 'venv']);
+    try {
+        const entries = fs.readdirSync(cwd, { withFileTypes: true });
+        const items = entries
+            .filter((e) => !IGNORE.has(e.name))
+            .slice(0, 20) // 最多 20 条
+            .map((e) => (e.isDirectory() ? `${e.name}/` : e.name));
+        return items.join(', ');
+    }
+    catch {
+        return '';
+    }
+}
+/** 检测技术栈 */
+function detectTechStack(cwd) {
+    const tags = [];
+    const exists = (f) => fs.existsSync(path.join(cwd, f));
+    // JavaScript / TypeScript 生态
+    if (exists('package.json')) {
+        tags.push('Node.js');
+        const pkg = readJsonSafe(path.join(cwd, 'package.json'));
+        const allDeps = { ...pkg?.dependencies, ...pkg?.devDependencies };
+        if (allDeps?.react)
+            tags.push('React');
+        if (allDeps?.vue)
+            tags.push('Vue');
+        if (allDeps?.next)
+            tags.push('Next.js');
+        if (allDeps?.express)
+            tags.push('Express');
+        if (allDeps?.nestjs || allDeps?.['@nestjs/core'])
+            tags.push('NestJS');
+    }
+    if (exists('tsconfig.json'))
+        tags.push('TypeScript');
+    // Python 生态
+    if (exists('requirements.txt') || exists('pyproject.toml') || exists('setup.py')) {
+        tags.push('Python');
+        if (exists('manage.py'))
+            tags.push('Django');
+        if (exists('app.py') || exists('wsgi.py'))
+            tags.push('Flask');
+    }
+    // Java 生态
+    if (exists('pom.xml'))
+        tags.push('Java', 'Maven');
+    if (exists('build.gradle') || exists('build.gradle.kts'))
+        tags.push('Java', 'Gradle');
+    // Go
+    if (exists('go.mod'))
+        tags.push('Go');
+    // Rust
+    if (exists('Cargo.toml'))
+        tags.push('Rust');
+    // Docker / DevOps
+    if (exists('Dockerfile') || exists('docker-compose.yml') || exists('docker-compose.yaml'))
+        tags.push('Docker');
+    if (exists('.github/workflows'))
+        tags.push('GitHub Actions');
+    return [...new Set(tags)];
+}
+/** 检测是否包含数据库相关内容 */
+function detectDatabase(cwd) {
+    const markers = [
+        'prisma', 'migrations', 'schema.prisma',
+        'knexfile.js', 'knexfile.ts', 'ormconfig.ts', 'ormconfig.json',
+        'sequelize.config.js', 'database.yml', 'db',
+        'sql', 'flyway', 'liquibase',
+    ];
+    try {
+        const entries = fs.readdirSync(cwd).map((e) => e.toLowerCase());
+        return markers.some((m) => entries.includes(m));
+    }
+    catch {
+        return false;
+    }
+}
+/** 检测是否包含财务/金融相关内容 */
+function detectFinance(cwd) {
+    const markers = ['finance', 'accounting', 'ledger', 'invoice', 'billing', 'payment'];
+    try {
+        const entries = fs.readdirSync(cwd).map((e) => e.toLowerCase());
+        return markers.some((m) => entries.some((e) => e.includes(m)));
+    }
+    catch {
+        return false;
+    }
+}
+/** 采集当前项目上下文 */
+function collectProjectContext() {
+    const cwd = process.cwd();
+    const pkg = readJsonSafe(path.join(cwd, 'package.json'));
+    return {
+        projectName: pkg?.name ?? path.basename(cwd),
+        description: pkg?.description ?? '',
+        techStack: detectTechStack(cwd),
+        topLevelStructure: getTopLevelStructure(cwd),
+        hasDatabase: detectDatabase(cwd),
+        hasFinance: detectFinance(cwd),
+    };
+}
+/** 将 ProjectContext 格式化为 prompt 片段 */
+function formatContextForPrompt(ctx) {
+    const lines = [];
+    lines.push(`项目名称: ${ctx.projectName}`);
+    if (ctx.description)
+        lines.push(`项目描述: ${ctx.description}`);
+    if (ctx.techStack.length > 0)
+        lines.push(`技术栈: ${ctx.techStack.join(', ')}`);
+    if (ctx.topLevelStructure)
+        lines.push(`目录概览: ${ctx.topLevelStructure}`);
+    if (ctx.hasDatabase)
+        lines.push('特征: 项目包含数据库相关文件');
+    if (ctx.hasFinance)
+        lines.push('特征: 项目包含财务/金融相关文件');
+    return lines.join('\n');
+}
+// ===== 兜底提示 =====
+/** 默认提示（LLM 不可用时的兜底） */
+const FALLBACK_HINTS = {
+    jarvis: 'Try "create a util logging.py that..."',
+    codereviewer: 'Try "review this function for potential issues..."',
+    dba: 'Try "optimize this slow SQL query..."',
+    financeadvisor: 'Try "分析这份利润表的关键指标..."',
+    stocktrader: 'Try "分析一下这只股票的趋势走势..."',
+};
+const DEFAULT_HINT = 'Try "create a util logging.py that..."';
+/** 获取角色对应的静态兜底提示（同步，可用于初始 placeholder） */
+export function getFallbackHint(agentName) {
+    if (agentName) {
+        return FALLBACK_HINTS[agentName.toLowerCase()] ?? DEFAULT_HINT;
+    }
+    const agent = getAgent(DEFAULT_AGENT);
+    const name = agent?.meta.name ?? 'Jarvis';
+    return FALLBACK_HINTS[name.toLowerCase()] ?? DEFAULT_HINT;
+}
+// ===== 格式清理 =====
+/** 将 LLM 返回的文本统一为 Try "..." 格式 */
+function normalizeHint(raw) {
+    let hint = raw.trim();
+    // 已经是标准格式
+    if (/^Try\s+".*"$/.test(hint))
+        return hint;
+    // Try "... 但没闭合
+    if (/^Try\s+"/.test(hint))
+        return hint.endsWith('"') ? hint : hint + '"';
+    // 去掉可能的引号包裹
+    hint = hint.replace(/^["'「]|["'」]$/g, '').trim();
+    return `Try "${hint}"`;
+}
+// ===== 主函数 =====
+/**
+ * 调用 LLM 生成一条符合当前角色 + 项目上下文的输入提示
+ *
+ * @returns 生成的提示文本，失败时返回静态兜底
+ */
+export async function generateAgentHint() {
+    const agent = getAgent(DEFAULT_AGENT);
+    const agentName = agent?.meta.name ?? 'Jarvis';
+    const fallback = getFallbackHint(agentName);
+    // 检查 LLM 是否可用
+    const config = loadConfig();
+    const activeModel = getActiveModel(config);
+    if (!activeModel || !activeModel.api_key) {
+        return fallback;
+    }
+    // 采集项目上下文
+    const ctx = collectProjectContext();
+    const contextBlock = formatContextForPrompt(ctx);
+    const llmConfig = getDefaultConfig();
+    const systemMsg = `你是一个提示词生成器。根据以下智能体角色信息和项目上下文，生成一条简短的示例输入提示，让用户知道可以问什么。
+
+## 角色信息
+角色名称: ${agentName}
+角色描述: ${agent?.meta.description ?? '通用助手'}
+角色氛围: ${agent?.meta.vibe ?? ''}
+
+## 当前项目上下文
+${contextBlock}
+
+## 要求
+1. 只输出一条提示文本，不要任何解释或前缀
+2. 格式为: Try "具体的示例问题..."
+3. 示例问题要具体、实用，体现角色的核心能力
+4. 必须结合当前项目上下文（技术栈、项目类型等），让提示与用户正在做的事情相关
+5. 长度控制在 50 个字符以内（Try "" 内的部分）
+6. 语言与角色描述保持一致`;
+    // 非流式请求，关闭思考模式以加速响应
+    async function doRequest(timeoutMs) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const url = llmConfig.baseUrl || 'https://api.openai.com/v1/chat/completions';
+            const requestBody = {
+                model: llmConfig.model,
+                messages: [
+                    { role: 'system', content: systemMsg },
+                    { role: 'user', content: '请生成一条输入提示。' },
+                ],
+                max_tokens: 100,
+                temperature: 0.8,
+                stream: false,
+                // GLM-4.7 / GLM-5 关闭深度思考（Z.AI 官方参数）
+                thinking: { type: 'disabled' },
+                // Ollama 原生关闭 thinking 模式
+                think: false,
+                // OpenAI 兼容格式关闭 thinking（Qwen 等）
+                chat_template_kwargs: { enable_thinking: false },
+            };
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${llmConfig.apiKey}`,
+                },
+                body: JSON.stringify(requestBody),
+                signal: controller.signal,
+            });
+            clearTimeout(timer);
+            if (!response.ok) {
+                const errBody = await response.text().catch(() => '');
+                console.error(`[hint] API 错误 ${response.status}: ${errBody.slice(0, 200)}`);
+                return null;
+            }
+            const data = await response.json();
+            // 兼容不同 API 的响应格式
+            const message = data.choices?.[0]?.message;
+            const text = message?.content?.trim() ||
+                // 部分模型（如 Ollama Gemma4 thinking 模式）内容在 reasoning 字段
+                message?.reasoning_content?.trim() ||
+                message?.reasoning?.trim() ||
+                data.result?.trim() ||
+                data.output?.text?.trim() ||
+                '';
+            if (!text) {
+                console.error('[hint] LLM 返回为空，原始响应:', JSON.stringify(data).slice(0, 300));
+                return null;
+            }
+            return text;
+        }
+        catch (err) {
+            clearTimeout(timer);
+            console.error(`[hint] 请求失败 (timeout=${timeoutMs}ms):`, err?.message ?? err);
+            return null;
+        }
+    }
+    // 本地模型推理慢，给更长超时；云端 API 保持短超时
+    const isLocal = /localhost|127\.0\.0\.1|10\.\d+\.\d+\.\d+|192\.168\./.test(llmConfig.baseUrl ?? '');
+    const timeoutMs = isLocal ? 30000 : 5000;
+    const text = await doRequest(timeoutMs);
+    if (!text)
+        return fallback;
+    return normalizeHint(text);
+}

package/dist/core/query.d.ts

@@ -0,0 +1,24 @@
+import { Message, LoopState, Tool, LLMService, TranscriptMessage } from '../types/index.js';
+/** 危险命令确认结果 */
+export type DangerConfirmResult = 'once' | 'always' | 'cancel';
+export interface QueryCallbacks {
+    onMessage: (msg: Message) => void;
+    onUpdateMessage: (id: string, updates: Partial<Message>) => void;
+    onStreamText: (text: string) => void;
+    /** 清空流式文本（每轮迭代结束时调用，避免 streamText 被工具消息挤到底部） */
+    onClearStreamText?: () => void;
+    onLoopStateChange: (state: LoopState) => void;
+    /**
+     * 危险命令确认回调 — 返回用户选择
+     * @param command 被拦截的命令
+     * @param reason 风险说明
+     * @param ruleName 匹配的规则名
+     */
+    onConfirmDangerousCommand?: (command: string, reason: string, ruleName: string) => Promise<DangerConfirmResult>;
+}
+/**
+ * 单轮 Agentic Loop：推理 → 工具调用 → 循环
+ */
+export declare function executeQuery(userInput: string, transcript: TranscriptMessage[], _tools: Tool[], service: LLMService, callbacks: QueryCallbacks, abortSignal: {
+    aborted: boolean;
+}): Promise<TranscriptMessage[]>;

package/dist/core/query.js

@@ -0,0 +1,245 @@
+import { v4 as uuid } from 'uuid';
+import { findToolMerged as findTool } from '../tools/index.js';
+import { MAX_ITERATIONS } from '../config/constants.js';
+import { sanitizeOutput, validateCommand, authorizeCommand, authorizeRule } from './safeguard.js';
+/**
+ * 单轮 Agentic Loop：推理 → 工具调用 → 循环
+ */
+export async function executeQuery(userInput, transcript, _tools, service, callbacks, abortSignal) {
+    const localTranscript = [...transcript];
+    localTranscript.push({ role: 'user', content: userInput });
+    const loopState = {
+        iteration: 0,
+        maxIterations: MAX_ITERATIONS,
+        isRunning: true,
+        aborted: false,
+    };
+    callbacks.onLoopStateChange({ ...loopState });
+    while (loopState.iteration < MAX_ITERATIONS && !abortSignal.aborted) {
+        loopState.iteration++;
+        callbacks.onLoopStateChange({ ...loopState });
+        const result = await runOneIteration(localTranscript, _tools, service, callbacks, abortSignal);
+        // 添加推理消息
+        if (result.text) {
+            const blocks = [{ type: 'text', text: result.text }];
+            if (result.toolCall) {
+                blocks.push({
+                    type: 'tool_use',
+                    id: result.toolCall.id,
+                    name: result.toolCall.name,
+                    input: result.toolCall.input,
+                });
+            }
+            localTranscript.push({ role: 'assistant', content: blocks });
+        }
+        else if (result.toolCall) {
+            localTranscript.push({
+                role: 'assistant',
+                content: [{
+                        type: 'tool_use',
+                        id: result.toolCall.id,
+                        name: result.toolCall.name,
+                        input: result.toolCall.input,
+                    }],
+            });
+        }
+        // 无工具调用 → 结束
+        if (!result.toolCall)
+            break;
+        if (abortSignal.aborted)
+            break;
+        // 执行工具
+        const tc = result.toolCall;
+        const toolResult = await executeTool(tc, callbacks);
+        localTranscript.push({
+            role: 'tool_result',
+            toolUseId: tc.id,
+            content: toolResult.content,
+        });
+        if (toolResult.isError)
+            break;
+    }
+    loopState.isRunning = false;
+    loopState.aborted = abortSignal.aborted;
+    callbacks.onLoopStateChange({ ...loopState });
+    // 如果被用户中断，在 transcript 中追加中断标记，让 LLM 知道上轮回复未完成
+    if (abortSignal.aborted) {
+        localTranscript.push({
+            role: 'user',
+            content: '[系统提示] 用户中断了上一轮回复（按下 ESC）。上一条助手消息可能不完整，请在后续回复中注意这一点。',
+        });
+    }
+    return localTranscript;
+}
+/** 执行一次 LLM 调用 */
+async function runOneIteration(transcript, tools, service, callbacks, abortSignal) {
+    const startTime = Date.now();
+    let accumulatedText = '';
+    let accumulatedThinking = '';
+    let toolCall = null;
+    let tokenCount = 0;
+    let firstTokenTime = null;
+    const thinkingId = uuid();
+    callbacks.onMessage({
+        id: thinkingId,
+        type: 'thinking',
+        status: 'pending',
+        content: '思考中...',
+        timestamp: Date.now(),
+    });
+    await new Promise((resolve, reject) => {
+        service
+            .streamMessage(transcript, tools, {
+            onThinking: (text) => {
+                if (abortSignal.aborted)
+                    return;
+                accumulatedThinking += text;
+                // 实时更新 thinking 消息内容，让用户看到思考过程
+                callbacks.onUpdateMessage(thinkingId, { content: accumulatedThinking });
+            },
+            onText: (text) => {
+                if (abortSignal.aborted) {
+                    resolve();
+                    return;
+                }
+                if (firstTokenTime === null) {
+                    firstTokenTime = Date.now();
+                    // 收到首 token，将 thinking 消息标记为完成（保留 think 内容）
+                    callbacks.onUpdateMessage(thinkingId, {
+                        status: 'success',
+                        content: accumulatedThinking ? '思考完成' : '',
+                        think: accumulatedThinking || undefined,
+                    });
+                }
+                tokenCount++;
+                accumulatedText += text;
+                callbacks.onStreamText(text);
+            },
+            onToolUse: (id, name, input) => {
+                if (abortSignal.aborted) {
+                    resolve();
+                    return;
+                }
+                toolCall = { id, name, input };
+                resolve();
+            },
+            onComplete: () => resolve(),
+            onError: (err) => reject(err),
+        }, abortSignal)
+            .catch(reject);
+    });
+    const duration = Date.now() - startTime;
+    const firstTokenLatency = firstTokenTime !== null ? firstTokenTime - startTime : 0;
+    const durationSec = duration / 1000;
+    const tokensPerSecond = durationSec > 0 ? tokenCount / durationSec : 0;
+    // 最终更新 thinking 消息状态
+    callbacks.onUpdateMessage(thinkingId, {
+        status: 'success',
+        content: accumulatedThinking ? '思考完成' : '',
+        think: accumulatedThinking || undefined,
+        duration,
+    });
+    if (accumulatedText) {
+        const isAborted = abortSignal.aborted;
+        // 先清空流式文本，再 push reasoning 消息，避免 streamText 被后续工具消息挤到底部
+        callbacks.onClearStreamText?.();
+        callbacks.onMessage({
+            id: uuid(),
+            type: 'reasoning',
+            status: isAborted ? 'aborted' : 'success',
+            content: accumulatedText,
+            timestamp: Date.now(),
+            duration,
+            tokenCount,
+            firstTokenLatency,
+            tokensPerSecond,
+            ...(isAborted ? { abortHint: '推理已中断（ESC）' } : {}),
+        });
+    }
+    return { text: accumulatedText, toolCall, duration, tokenCount, firstTokenLatency, tokensPerSecond };
+}
+/** 执行工具并返回结果 */
+async function executeTool(tc, callbacks) {
+    const toolExecId = uuid();
+    // 对 Bash 工具使用更直观的显示格式
+    const displayContent = tc.name === 'Bash' && tc.input.command
+        ? `Bash(${tc.input.command})`
+        : `调用工具: ${tc.name}`;
+    callbacks.onMessage({
+        id: toolExecId,
+        type: 'tool_exec',
+        status: 'pending',
+        content: displayContent,
+        timestamp: Date.now(),
+        toolName: tc.name,
+        toolArgs: tc.input,
+    });
+    // ===== 安全围栏：Bash 命令拦截 + 交互式确认 =====
+    if (tc.name === 'Bash' && tc.input.command) {
+        const command = tc.input.command;
+        const check = validateCommand(command);
+        if (!check.allowed) {
+            if (!check.canOverride) {
+                // critical 级别：直接禁止
+                const errMsg = `${check.reason}\n🚫 该命令已被永久禁止，无法通过授权绕过。\n命令: ${command}`;
+                callbacks.onUpdateMessage(toolExecId, { status: 'error', content: errMsg, toolResult: errMsg });
+                return { content: `错误: ${errMsg}`, isError: true };
+            }
+            // high 级别：弹出交互式确认
+            if (callbacks.onConfirmDangerousCommand) {
+                const ruleName = check.rule?.name ?? 'unknown';
+                const reason = check.reason ?? '未知风险';
+                const userChoice = await callbacks.onConfirmDangerousCommand(command, reason, ruleName);
+                if (userChoice === 'cancel') {
+                    const cancelMsg = `⛔ 用户取消执行危险命令: ${command}`;
+                    callbacks.onUpdateMessage(toolExecId, { status: 'error', content: cancelMsg, toolResult: cancelMsg });
+                    return { content: cancelMsg, isError: true };
+                }
+                // 根据用户选择授权
+                if (userChoice === 'once') {
+                    authorizeCommand(command, 'once', ruleName);
+                }
+                else if (userChoice === 'always') {
+                    authorizeRule(ruleName, 'always');
+                }
+            }
+            else {
+                // 没有确认回调，直接拒绝
+                const errMsg = `${check.reason}\n命令: ${command}`;
+                callbacks.onUpdateMessage(toolExecId, { status: 'error', content: errMsg, toolResult: errMsg });
+                return { content: `错误: ${errMsg}`, isError: true };
+            }
+        }
+    }
+    const tool = findTool(tc.name);
+    if (!tool) {
+        const errMsg = `未知工具: ${tc.name}`;
+        callbacks.onUpdateMessage(toolExecId, { status: 'error', content: errMsg });
+        return { content: errMsg, isError: true };
+    }
+    try {
+        const start = Date.now();
+        const result = await tool.execute(tc.input);
+        // 对工具输出统一脱敏
+        const safeResult = sanitizeOutput(result);
+        const doneContent = tc.name === 'Bash' && tc.input.command
+            ? `Bash(${tc.input.command}) 执行完成`
+            : `工具 ${tc.name} 执行完成`;
+        callbacks.onUpdateMessage(toolExecId, {
+            status: 'success',
+            content: doneContent,
+            toolResult: safeResult,
+            duration: Date.now() - start,
+        });
+        return { content: safeResult, isError: false };
+    }
+    catch (err) {
+        const errMsg = err.message || '工具执行失败';
+        callbacks.onUpdateMessage(toolExecId, {
+            status: 'error',
+            content: errMsg,
+            toolResult: errMsg,
+        });
+        return { content: `错误: ${errMsg}`, isError: false };
+    }
+}

package/dist/core/safeguard.d.ts

@@ -0,0 +1,96 @@
+/**
+ * 统一安全围栏 — 危险命令拦截 + 敏感信息保护 + 双模式授权
+ *
+ * 授权模式：
+ *   1. 临时授权（once）  — 仅当前会话有效，会话重置后失效
+ *   2. 持久授权（always）— 写入 ~/.jarvis/.permissions.json，跨会话永久生效
+ *
+ * critical 级别命令不可授权，high 级别支持两种授权模式。
+ */
+export interface DangerRule {
+    /** 规则名称（唯一标识） */
+    name: string;
+    /** 匹配正则 */
+    pattern: RegExp;
+    /** 风险等级: high 需要用户确认, critical 直接禁止 */
+    level: 'high' | 'critical';
+    /** 风险说明 */
+    reason: string;
+}
+/** 危险命令规则表 */
+export declare const DANGER_RULES: DangerRule[];
+export interface SensitivePattern {
+    name: string;
+    pattern: RegExp;
+    replacement: string;
+}
+/** 敏感信息匹配规则 — 用于输出脱敏 */
+export declare const SENSITIVE_PATTERNS: SensitivePattern[];
+/** 授权模式 */
+export type AuthMode = 'once' | 'always';
+/** 持久化授权记录 */
+export interface PermissionEntry {
+    /** 授权的规则名称（对应 DangerRule.name） */
+    ruleName: string;
+    /** 授权的具体命令（可选，为空表示授权整个规则） */
+    command?: string;
+    /** 授权时间 */
+    grantedAt: string;
+    /** 备注 */
+    note?: string;
+}
+/** .permissions.json 文件结构 */
+export interface PermissionsFile {
+    /** 文件说明 */
+    _comment: string;
+    /** 按规则名称授权（授权整类命令） */
+    rules: string[];
+    /** 按具体命令授权 */
+    commands: PermissionEntry[];
+}
+/**
+ * 授权命令
+ * @param command 具体命令字符串
+ * @param mode 'once' 仅本次会话 | 'always' 持久化到文件
+ * @param ruleName 可选，关联的规则名称
+ */
+export declare function authorizeCommand(command: string, mode?: AuthMode, ruleName?: string): void;
+/**
+ * 按规则名称授权（整类命令放行）
+ * @param ruleName 规则名称（对应 DangerRule.name）
+ * @param mode 'once' 仅本次会话 | 'always' 持久化到文件
+ */
+export declare function authorizeRule(ruleName: string, mode?: AuthMode): void;
+/**
+ * 撤销持久化授权
+ * @param target 规则名称或具体命令
+ */
+export declare function revokeAuthorization(target: string): boolean;
+/** 列出所有持久化授权 */
+export declare function listPermanentAuthorizations(): PermissionsFile;
+/** 检查命令是否已授权（临时 + 持久化） */
+export declare function isAuthorized(command: string, ruleName?: string): boolean;
+/** 清空会话级临时授权（会话重置时调用，不影响持久化授权） */
+export declare function clearAuthorizations(): void;
+export interface SafeguardResult {
+    /** 是否允许执行 */
+    allowed: boolean;
+    /** 拒绝原因 */
+    reason?: string;
+    /** 匹配到的规则 */
+    rule?: DangerRule;
+    /** 是否可通过用户确认放行 */
+    canOverride?: boolean;
+}
+/**
+ * 校验命令是否安全
+ */
+export declare function validateCommand(command: string): SafeguardResult;
+/**
+ * 对输出文本进行敏感信息脱敏
+ */
+export declare function sanitizeOutput(text: string): string;
+/**
+ * 检查文件写入内容是否包含硬编码敏感信息
+ */
+export declare function detectSensitiveContent(content: string): string[];