@qlingzzy/qling 1.0.0

package/dist/knowledge-agent.d.ts

@@ -0,0 +1,47 @@
+import { ToolCall, ToolResult } from "./types.js";
+import { MemoryStore } from "./memory.js";
+export interface Observation {
+    type: "tool_use" | "file_created" | "file_modified" | "error" | "concept" | "decision";
+    content: string;
+    metadata?: Record<string, string>;
+    timestamp: number;
+    confidence: number;
+}
+export interface KnowledgeItem {
+    id: string;
+    observation: Observation;
+    promoted: boolean;
+    tags: string[];
+}
+export declare class KnowledgeObserver {
+    private observations;
+    private pendingItems;
+    private memoryStore;
+    private turnCount;
+    private toolUseCounts;
+    private errorCounts;
+    constructor(memoryStore: MemoryStore);
+    observeUserMessage(content: string): void;
+    observeToolCall(toolCall: ToolCall): void;
+    observeToolResult(result: ToolResult, toolName: string): void;
+    observeAssistantMessage(content: string): void;
+    getContextualObservations(query: string, limit?: number): Observation[];
+    promoteToMemory(force?: boolean): Promise<number>;
+    generateReport(): string;
+    private addObservation;
+    private extractTags;
+    private isAlreadyInMemory;
+}
+export declare class KnowledgeAgentAdapter {
+    private observer;
+    private memoryStore;
+    private reportInterval;
+    constructor(memoryStore: MemoryStore);
+    onUserMessage(content: string): void;
+    onToolCall(toolCall: ToolCall): void;
+    onToolResult(result: ToolResult, toolName: string): void;
+    onAssistantMessage(content: string): void;
+    onTurnEnd(turnCount: number): Promise<void>;
+    getObserver(): KnowledgeObserver;
+}
+//# sourceMappingURL=knowledge-agent.d.ts.map

package/dist/knowledge-agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-agent.d.ts","sourceRoot":"","sources":["../src/knowledge-agent.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAwB,MAAM,YAAY,CAAC;AACxE,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAI1C,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,UAAU,GAAG,cAAc,GAAG,eAAe,GAAG,OAAO,GAAG,SAAS,GAAG,UAAU,CAAC;IACvF,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,WAAW,CAAC;IACzB,QAAQ,EAAE,OAAO,CAAC;IAClB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AA6CD,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,YAAY,CAAqB;IACzC,OAAO,CAAC,YAAY,CAAuB;IAC3C,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,SAAS,CAAa;IAC9B,OAAO,CAAC,aAAa,CAAkC;IACvD,OAAO,CAAC,WAAW,CAAkC;gBAEzC,WAAW,EAAE,WAAW;IAKpC,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAkCzC,eAAe,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IA0CzC,iBAAiB,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAoC7D,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAgB9C,yBAAyB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,GAAE,MAAU,GAAG,WAAW,EAAE;IAkBpE,eAAe,CAAC,KAAK,GAAE,OAAe,GAAG,OAAO,CAAC,MAAM,CAAC;IAiC9D,cAAc,IAAI,MAAM;IA0CxB,OAAO,CAAC,cAAc;IActB,OAAO,CAAC,WAAW;YAYL,iBAAiB;CAKhC;AAID,qBAAa,qBAAqB;IAChC,OAAO,CAAC,QAAQ,CAAoB;IACpC,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,cAAc,CAAc;gBAExB,WAAW,EAAE,WAAW;IAMpC,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAKpC,UAAU,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAKpC,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAKxD,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAKnC,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAejD,WAAW,IAAI,iBAAiB;CAGjC"}

package/dist/knowledge-agent.js

@@ -0,0 +1,320 @@
+// ============================================================
+// 轻灵 - s07 Knowledge Agent（观察者模式）
+// 参考 Microsoft AI Agents for Beginners Lesson 13 & 14
+// 将 AutoDream 升级为知识观察者，主动学习项目上下文
+// ============================================================
+// --- 工具使用模式库 ---
+const TOOL_USE_PATTERNS = [
+    // Git 操作
+    { tool: "bash", pattern: /\b(git\s+(add|commit|push|pull|merge|rebase|clone))\b/, tag: "git" },
+    // 包管理
+    { tool: "bash", pattern: /\b(npm\s+(install|run|test|build)|pip\s+install|yarn\s+(add|install))\b/, tag: "package-manager" },
+    // Docker
+    { tool: "bash", pattern: /\b(docker\s+(build|run|pull|ps|exec|logs))\b/, tag: "docker" },
+    // Kubernetes
+    { tool: "bash", pattern: /\b(kubectl\s+(get|apply|describe|logs|exec))\b/, tag: "kubernetes" },
+    // Python
+    { tool: "bash", pattern: /\b(python3?|pip3?|uv\s+)/, tag: "python" },
+    // TypeScript
+    { tool: "bash", pattern: /\b(npx|tsc|yarn\s+(dev|build))\b/, tag: "typescript" },
+    // 文件操作
+    { tool: "bash", pattern: /\b(ls|mkdir|rm|cp|mv|chmod|chown)\b/, tag: "file-ops" },
+    // 进程/服务
+    { tool: "bash", pattern: /\b(ps|kill|pkill|grep|top|htop)\b/, tag: "process" },
+];
+// --- 文件变化模式 ---
+const FILE_CREATED_PATTERNS = [
+    /文件已写入:\s*(.+)/,
+    /✅.*已创建:\s*(.+)/,
+    /created:\s*(.+)/i,
+];
+const FILE_MODIFIED_PATTERNS = [
+    /修改了\s*(.+)/,
+    /updated:\s*(.+)/i,
+    /patched:\s*(.+)/i,
+];
+// --- 错误模式 ---
+const ERROR_PATTERNS = [
+    { pattern: /Error:\s*(.+)/i, tag: "generic-error" },
+    { pattern: /Traceback\s*\([^)]*\):\s*(.+)/i, tag: "python-error" },
+    { pattern: /SyntaxError:\s*(.+)/i, tag: "syntax-error" },
+    { pattern: /NotADirectoryError/i, tag: "path-error" },
+    { pattern: /WinError:\s*(.+)/i, tag: "windows-error" },
+    { pattern: /ModuleNotFoundError:\s*(.+)/i, tag: "import-error" },
+];
+export class KnowledgeObserver {
+    observations = [];
+    pendingItems = [];
+    memoryStore;
+    turnCount = 0;
+    toolUseCounts = new Map();
+    errorCounts = new Map();
+    constructor(memoryStore) {
+        this.memoryStore = memoryStore;
+    }
+    // --- 观察用户消息 ---
+    observeUserMessage(content) {
+        this.turnCount++;
+        // 提取概念和决策
+        const conceptPatterns = [
+            /(?:使用|采用)\s+(\S+)\s+(?:框架|库|工具|方案)/g,
+            /(?:决定|选定)\s+(\S+)/g,
+            /(?:目标|计划)\s+[:-]\s*(.+)/g,
+        ];
+        for (const pat of conceptPatterns) {
+            let match;
+            while ((match = pat.exec(content)) !== null) {
+                this.addObservation({
+                    type: "concept",
+                    content: `用户提到: ${match[1].trim()}`,
+                    timestamp: Date.now(),
+                    confidence: 0.7,
+                });
+            }
+        }
+        // 观察是否有明确的决策
+        if (/决定|选定|采用|选择|不|不要/i.test(content)) {
+            this.addObservation({
+                type: "decision",
+                content: content.slice(0, 200),
+                timestamp: Date.now(),
+                confidence: 0.8,
+            });
+        }
+    }
+    // --- 观察工具调用 ---
+    observeToolCall(toolCall) {
+        const toolName = toolCall.name;
+        // 记录工具使用次数
+        this.toolUseCounts.set(toolName, (this.toolUseCounts.get(toolName) ?? 0) + 1);
+        // 提取工具使用模式
+        for (const entry of TOOL_USE_PATTERNS) {
+            if (entry.tool !== toolName)
+                continue;
+            const cmd = String(toolCall.arguments.command ?? "");
+            const match = entry.pattern.exec(cmd);
+            if (match) {
+                this.addObservation({
+                    type: "tool_use",
+                    content: `使用 ${entry.tag}: ${cmd.slice(0, 100)}`,
+                    metadata: { tool: toolName, tag: entry.tag, command: cmd.slice(0, 100) },
+                    timestamp: Date.now(),
+                    confidence: 0.9,
+                });
+            }
+        }
+        // 文件路径提取
+        const pathPatterns = [
+            /([\/.a-zA-Z0-9_-]+\.(ts|js|py|json|md|yaml|yml|sh|bash))/g,
+        ];
+        for (const pat of pathPatterns) {
+            let match;
+            const argsStr = JSON.stringify(toolCall.arguments);
+            while ((match = pat.exec(argsStr)) !== null) {
+                this.addObservation({
+                    type: "file_modified",
+                    content: `涉及文件: ${match[1]}`,
+                    metadata: { file: match[1] },
+                    timestamp: Date.now(),
+                    confidence: 0.8,
+                });
+            }
+        }
+    }
+    // --- 观察工具结果 ---
+    observeToolResult(result, toolName) {
+        if (result.is_error) {
+            // 错误观察
+            for (const ep of ERROR_PATTERNS) {
+                const match = ep.pattern.exec(result.output);
+                if (match) {
+                    const tag = ep.tag;
+                    this.errorCounts.set(tag, (this.errorCounts.get(tag) ?? 0) + 1);
+                    this.addObservation({
+                        type: "error",
+                        content: `错误 [${tag}]: ${match[1].slice(0, 150)}`,
+                        metadata: { errorType: tag, errorDetail: match[1].slice(0, 150) },
+                        timestamp: Date.now(),
+                        confidence: 0.9,
+                    });
+                }
+            }
+        }
+        else {
+            // 成功结果 — 检查是否有文件创建
+            for (const pat of FILE_CREATED_PATTERNS) {
+                const match = pat.exec(result.output);
+                if (match) {
+                    this.addObservation({
+                        type: "file_created",
+                        content: `创建文件: ${match[1]}`,
+                        metadata: { file: match[1] },
+                        timestamp: Date.now(),
+                        confidence: 0.85,
+                    });
+                }
+            }
+        }
+    }
+    // --- 观察 assistant 回复 ---
+    observeAssistantMessage(content) {
+        // 检查是否提到了某个工具的使用意图
+        const toolMentions = content.match(/\b(read|write|bash|todo|skill)\b/g);
+        if (toolMentions) {
+            const unique = Array.from(new Set(toolMentions));
+            this.addObservation({
+                type: "tool_use",
+                content: `助手计划使用工具: ${unique.join(", ")}`,
+                metadata: { plannedTools: unique.join(",") },
+                timestamp: Date.now(),
+                confidence: 0.5, // 低置信度，因为只是计划
+            });
+        }
+    }
+    // --- 主动观察：从记忆获取上下文 ---
+    getContextualObservations(query, limit = 5) {
+        const keywords = query.toLowerCase().split(/\s+/);
+        const scored = this.observations.map((obs) => {
+            let score = obs.confidence;
+            const content = obs.content.toLowerCase();
+            for (const kw of keywords) {
+                if (content.includes(kw))
+                    score += 0.2;
+            }
+            return { obs, score };
+        });
+        return scored
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit)
+            .map((s) => s.obs);
+    }
+    // --- 定期将观察提升为记忆 ---
+    async promoteToMemory(force = false) {
+        const threshold = this.turnCount > 0 ? Math.max(5, this.turnCount / 4) : 5;
+        if (!force && this.turnCount < threshold) {
+            return 0;
+        }
+        const observationsToPromote = [];
+        for (const o of this.observations) {
+            if (o.confidence >= 0.8 && !(await this.isAlreadyInMemory(o))) {
+                observationsToPromote.push(o);
+            }
+        }
+        let promoted = 0;
+        for (const obs of observationsToPromote) {
+            const tags = this.extractTags(obs);
+            this.memoryStore.add(`[知识观察] ${obs.content}`, "auto-dream", obs.confidence);
+            promoted++;
+        }
+        if (promoted > 0) {
+            await this.memoryStore.saveToDisk();
+        }
+        return promoted;
+    }
+    // --- 生成观察报告 ---
+    generateReport() {
+        const lines = [];
+        lines.push(`📊 知识观察报告（第 ${this.turnCount} 轮）`);
+        lines.push("");
+        // 工具使用统计
+        if (this.toolUseCounts.size > 0) {
+            lines.push("🔧 工具使用统计:");
+            const sorted = Array.from(this.toolUseCounts.entries()).sort((a, b) => b[1] - a[1]);
+            for (const [tool, count] of sorted) {
+                lines.push(`  • ${tool}: ${count} 次`);
+            }
+            lines.push("");
+        }
+        // 错误统计
+        if (this.errorCounts.size > 0) {
+            lines.push("❌ 错误统计:");
+            for (const [err, count] of Array.from(this.errorCounts.entries())) {
+                lines.push(`  • ${err}: ${count} 次`);
+            }
+            lines.push("");
+        }
+        // 最近观察
+        if (this.observations.length > 0) {
+            lines.push("🧠 最近观察:");
+            const recent = this.observations.slice(-5).reverse();
+            for (const obs of recent) {
+                const icon = obs.type === "error" ? "❌" : obs.type === "tool_use" ? "🔧" : obs.type === "concept" ? "💡" : "📄";
+                lines.push(`  ${icon} ${obs.content.slice(0, 80)}`);
+            }
+        }
+        return lines.join("\n");
+    }
+    // --- Private ---
+    addObservation(obs) {
+        // 去重
+        const exists = this.observations.some((o) => o.content === obs.content && o.type === obs.type);
+        if (!exists) {
+            this.observations.push(obs);
+            // 保留最近 200 条观察
+            if (this.observations.length > 200) {
+                this.observations = this.observations.slice(-200);
+            }
+        }
+    }
+    extractTags(obs) {
+        const tags = [];
+        if (obs.metadata) {
+            if (obs.metadata.tag)
+                tags.push(obs.metadata.tag);
+            if (obs.metadata.errorType)
+                tags.push(obs.metadata.errorType);
+            if (obs.metadata.plannedTools) {
+                tags.push(...obs.metadata.plannedTools.split(","));
+            }
+        }
+        return tags;
+    }
+    async isAlreadyInMemory(obs) {
+        // 检查 content 是否已在持久化记忆中
+        const existing = await this.memoryStore.getRelevant(obs.content, 20);
+        return existing.some((e) => e.content.includes(obs.content.slice(0, 50)));
+    }
+}
+// --- 与 AgentLoop 集成的观察者适配器 ---
+export class KnowledgeAgentAdapter {
+    observer;
+    memoryStore;
+    reportInterval = 10; // 每 N 轮输出一次报告
+    constructor(memoryStore) {
+        this.memoryStore = memoryStore;
+        this.observer = new KnowledgeObserver(memoryStore);
+    }
+    // 在每次 user message 后调用
+    onUserMessage(content) {
+        this.observer.observeUserMessage(content);
+    }
+    // 在每次 tool call 前调用
+    onToolCall(toolCall) {
+        this.observer.observeToolCall(toolCall);
+    }
+    // 在每次 tool result 后调用
+    onToolResult(result, toolName) {
+        this.observer.observeToolResult(result, toolName);
+    }
+    // 在每次 assistant message 后调用
+    onAssistantMessage(content) {
+        this.observer.observeAssistantMessage(content);
+    }
+    // 在每个 turn 结束时调用（由 AgentLoop 调用）
+    async onTurnEnd(turnCount) {
+        if (turnCount % this.reportInterval === 0) {
+            const report = this.observer.generateReport();
+            console.error(`\n${report}\n`);
+        }
+        // 每 20 轮自动将观察提升为记忆
+        if (turnCount % 20 === 0) {
+            const promoted = await this.observer.promoteToMemory(false);
+            if (promoted > 0) {
+                console.error(`💾 [KnowledgeAgent] 已将 ${promoted} 条观察提升为记忆`);
+            }
+        }
+    }
+    getObserver() {
+        return this.observer;
+    }
+}

package/dist/local-status-report.d.ts

@@ -0,0 +1,23 @@
+import type { QlingConfig } from "./config.js";
+export interface LocalStatusReport {
+    provider: string;
+    model: string;
+    endpoint: string;
+    apiKeyStatus: "missing" | "set(redacted)";
+    workspaceDir: string;
+    stateDir: string;
+    cacheDir: string;
+    branch: string;
+    sessionsCount: number;
+    exportsCount: number;
+    permissionMode: string;
+    mcpEnabled: number;
+    mcpTotal: number;
+    hooksEnabled: boolean;
+}
+export interface LocalStatusOptions {
+    gitBranch?: (workspaceDir?: string) => string | null;
+}
+export declare function buildLocalStatusReport(config: QlingConfig, options?: LocalStatusOptions): Promise<LocalStatusReport>;
+export declare function formatLocalStatusReport(report: LocalStatusReport): string[];
+//# sourceMappingURL=local-status-report.d.ts.map

package/dist/local-status-report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-status-report.d.ts","sourceRoot":"","sources":["../src/local-status-report.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAM/C,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,SAAS,GAAG,eAAe,CAAC;IAC1C,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,kBAAkB;IACjC,SAAS,CAAC,EAAE,CAAC,YAAY,CAAC,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;CACtD;AAeD,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,WAAW,EACnB,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,iBAAiB,CAAC,CA6B5B;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,EAAE,CAgB3E"}

package/dist/local-status-report.js

@@ -0,0 +1,63 @@
+import { readdir } from "fs/promises";
+import { join } from "path";
+import { sanitizeEndpoint } from "./config-report.js";
+import { buildLocalHooksReport } from "./hooks-report.js";
+import { buildLocalMcpReport } from "./mcp-report.js";
+import { resolveGitBranch } from "./statusline.js";
+function safeText(value, fallback = "-") {
+    return typeof value === "string" && value.trim() ? value.trim() : fallback;
+}
+async function countFilesByExtension(dir, extension) {
+    try {
+        const entries = await readdir(dir, { withFileTypes: true });
+        return entries.filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(extension)).length;
+    }
+    catch {
+        return 0;
+    }
+}
+export async function buildLocalStatusReport(config, options = {}) {
+    const workspaceDir = safeText(config.runtime.workspace_dir, process.cwd());
+    const stateDir = safeText(config.runtime.file_state_dir);
+    const cacheDir = safeText(config.runtime.file_cache_dir);
+    const branch = (options.gitBranch ?? resolveGitBranch)(workspaceDir);
+    const mcp = buildLocalMcpReport(config.mcp);
+    const hooks = buildLocalHooksReport(config.guard);
+    const [sessionsCount, exportsCount] = await Promise.all([
+        countFilesByExtension(join(stateDir, "sessions"), ".json"),
+        countFilesByExtension(join(stateDir, "exports"), ".md"),
+    ]);
+    return {
+        provider: safeText(config.llm.provider),
+        model: safeText(config.llm.model),
+        endpoint: sanitizeEndpoint(config.llm.endpoint),
+        apiKeyStatus: safeText(config.llm.api_key, "") ? "set(redacted)" : "missing",
+        workspaceDir,
+        stateDir,
+        cacheDir,
+        branch: branch ?? "-",
+        sessionsCount,
+        exportsCount,
+        permissionMode: safeText(config.guard.permissions.default, "allow"),
+        mcpEnabled: mcp.enabled,
+        mcpTotal: mcp.total,
+        hooksEnabled: hooks.guardEnabled,
+    };
+}
+export function formatLocalStatusReport(report) {
+    return [
+        "",
+        "📍 本地状态",
+        "-----------------------------------------",
+        `Runtime   : provider=${report.provider} model=${report.model} endpoint=${report.endpoint} api_key=${report.apiKeyStatus}`,
+        `Workspace : ${report.workspaceDir}`,
+        `State     : ${report.stateDir}`,
+        `Cache     : ${report.cacheDir}`,
+        `Git       : branch=${report.branch}`,
+        `Local data: sessions=${report.sessionsCount} exports=${report.exportsCount}`,
+        `Control   : permission=${report.permissionMode} MCP=${report.mcpEnabled}/${report.mcpTotal} hooks=${report.hooksEnabled ? "on" : "off"}`,
+        "-----------------------------------------",
+        "边界      : 只读取本地配置和文件元数据；不读取会话/导出正文、不连接 MCP、不运行 hooks、不调用模型、不联网、不写配置。",
+        "",
+    ];
+}

package/dist/local-storage-report.d.ts

@@ -0,0 +1,32 @@
+import type { SlashCommandContext } from "./commands/runtime.js";
+export type LocalStorageBucketId = "state" | "sessions" | "exports" | "cache";
+export interface LocalStorageBucket {
+    id: LocalStorageBucketId;
+    label: string;
+    path: string;
+    exists: boolean;
+    fileCount: number;
+    dirCount: number;
+    otherCount: number;
+    sizeBytes: number;
+    scannedEntries: number;
+    truncated: boolean;
+    error: string | null;
+}
+export interface LocalStorageReport {
+    workspaceDir: string;
+    stateDir: string;
+    sessionsDir: string;
+    exportsDir: string;
+    cacheDir: string;
+    scanLimit: number;
+    buckets: LocalStorageBucket[];
+}
+export interface LocalStorageReportOptions {
+    env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
+    maxEntries?: number;
+}
+export declare function formatBytes(bytes: number): string;
+export declare function buildLocalStorageReport(context: SlashCommandContext, options?: LocalStorageReportOptions): Promise<LocalStorageReport>;
+export declare function formatLocalStorageReport(report: LocalStorageReport): string[];
+//# sourceMappingURL=local-storage-report.d.ts.map

package/dist/local-storage-report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-storage-report.d.ts","sourceRoot":"","sources":["../src/local-storage-report.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAKjE,MAAM,MAAM,oBAAoB,GAAG,OAAO,GAAG,UAAU,GAAG,SAAS,GAAG,OAAO,CAAC;AAE9E,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,oBAAoB,CAAC;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB;AAED,MAAM,WAAW,kBAAkB;IACjC,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,kBAAkB,EAAE,CAAC;CAC/B;AAED,MAAM,WAAW,yBAAyB;IACxC,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IAC7D,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AA8BD,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAWjD;AA8ED,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,mBAAmB,EAC5B,OAAO,GAAE,yBAA8B,GACtC,OAAO,CAAC,kBAAkB,CAAC,CA+B7B;AASD,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM,EAAE,CAyB7E"}

package/dist/local-storage-report.js

@@ -0,0 +1,171 @@
+import { lstat, readdir } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import { resolveSessionExportsDir } from "./session-export.js";
+const DEFAULT_SCAN_LIMIT = 5000;
+function resolveStateDir(context, env) {
+    const agentLoop = context.agentLoop;
+    return env?.QLING_FILE_STATE_DIR
+        || agentLoop.getRuntimeRootDir?.()
+        || join(homedir(), ".qling");
+}
+function resolveCacheDir(env, stateDir) {
+    return env?.QLING_FILE_CACHE_DIR || join(stateDir, "cache");
+}
+function resolveScanLimit(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0
+        ? Math.floor(value)
+        : DEFAULT_SCAN_LIMIT;
+}
+function isNotFoundError(error) {
+    return Boolean(error && typeof error === "object" && error.code === "ENOENT");
+}
+function errorToString(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function formatBytes(bytes) {
+    const safeBytes = Math.max(0, Number(bytes) || 0);
+    if (safeBytes < 1024)
+        return `${safeBytes} B`;
+    const units = ["KB", "MB", "GB", "TB"];
+    let value = safeBytes / 1024;
+    let unitIndex = 0;
+    while (value >= 1024 && unitIndex < units.length - 1) {
+        value /= 1024;
+        unitIndex += 1;
+    }
+    return `${value.toFixed(value >= 10 ? 0 : 1)} ${units[unitIndex]}`;
+}
+async function scanBucket(id, label, path, scanLimit) {
+    const bucket = {
+        id,
+        label,
+        path,
+        exists: true,
+        fileCount: 0,
+        dirCount: 0,
+        otherCount: 0,
+        sizeBytes: 0,
+        scannedEntries: 0,
+        truncated: false,
+        error: null,
+    };
+    async function walk(targetPath) {
+        if (bucket.scannedEntries >= scanLimit) {
+            bucket.truncated = true;
+            return;
+        }
+        let entry;
+        try {
+            entry = await lstat(targetPath);
+        }
+        catch (error) {
+            if (isNotFoundError(error) && targetPath === path) {
+                bucket.exists = false;
+                return;
+            }
+            bucket.error = errorToString(error);
+            return;
+        }
+        bucket.scannedEntries += 1;
+        if (entry.isDirectory()) {
+            bucket.dirCount += 1;
+            let children;
+            try {
+                children = await readdir(targetPath);
+            }
+            catch (error) {
+                bucket.error = errorToString(error);
+                return;
+            }
+            for (const child of children) {
+                if (bucket.scannedEntries >= scanLimit) {
+                    bucket.truncated = true;
+                    break;
+                }
+                await walk(join(targetPath, child));
+            }
+            return;
+        }
+        if (entry.isFile()) {
+            bucket.fileCount += 1;
+            bucket.sizeBytes += entry.size;
+            return;
+        }
+        bucket.otherCount += 1;
+        bucket.sizeBytes += entry.size;
+    }
+    await walk(path);
+    if (!bucket.exists) {
+        bucket.fileCount = 0;
+        bucket.dirCount = 0;
+        bucket.otherCount = 0;
+        bucket.sizeBytes = 0;
+        bucket.scannedEntries = 0;
+        bucket.truncated = false;
+        bucket.error = null;
+    }
+    return bucket;
+}
+export async function buildLocalStorageReport(context, options = {}) {
+    const env = options.env ?? process.env;
+    const stateDir = resolveStateDir(context, env);
+    const sessionsDir = join(stateDir, "sessions");
+    const exportsDir = resolveSessionExportsDir(context, env);
+    const cacheDir = resolveCacheDir(env, stateDir);
+    const scanLimit = resolveScanLimit(options.maxEntries);
+    const agentLoop = context.agentLoop;
+    const workspaceDir = context.workspaceDir || agentLoop.getWorkspaceDir?.() || process.cwd();
+    const bucketDefs = [
+        ["state", "State dir", stateDir],
+        ["sessions", "Sessions", sessionsDir],
+        ["exports", "Exports", exportsDir],
+        ["cache", "Cache", cacheDir],
+    ];
+    const buckets = [];
+    for (const [id, label, path] of bucketDefs) {
+        buckets.push(await scanBucket(id, label, path, scanLimit));
+    }
+    return {
+        workspaceDir,
+        stateDir,
+        sessionsDir,
+        exportsDir,
+        cacheDir,
+        scanLimit,
+        buckets,
+    };
+}
+function bucketStatus(bucket) {
+    if (!bucket.exists)
+        return "missing";
+    if (bucket.error)
+        return `warn (${bucket.error})`;
+    if (bucket.truncated)
+        return "truncated";
+    return "ok";
+}
+export function formatLocalStorageReport(report) {
+    const lines = [
+        "",
+        "💾 本地存储盘点",
+        "-----------------------------------------",
+        `Workspace : ${report.workspaceDir}`,
+        `Scan cap  : ${report.scanLimit} entries per bucket`,
+        "",
+    ];
+    for (const bucket of report.buckets) {
+        lines.push(`${bucket.label}`);
+        lines.push(`  Status    : ${bucketStatus(bucket)}`);
+        lines.push(`  Files     : ${bucket.fileCount}`);
+        lines.push(`  Dirs      : ${bucket.dirCount}`);
+        lines.push(`  Other     : ${bucket.otherCount}`);
+        lines.push(`  Size      : ${formatBytes(bucket.sizeBytes)}`);
+        lines.push(`  Path      : ${bucket.path}`);
+    }
+    lines.push("-----------------------------------------");
+    lines.push("说明      : 只读取本地文件元数据，不读取文件正文、不调用模型、不联网。");
+    lines.push("提示      : 用 /privacy 看数据边界，用 /exports 查看 Markdown 导出。");
+    lines.push("");
+    return lines;
+}

package/dist/mcp/bridge.d.ts

@@ -0,0 +1,11 @@
+import type { MCPToolDefinition, MCPServerConfig } from "./types.js";
+import type { ToolDefinition } from "../types.js";
+export declare function mcpToolFullName(serverName: string, toolName: string): string;
+export declare function isMCPTool(toolName: string): boolean;
+export declare function parseMCPToolName(toolName: string): {
+    serverName: string;
+    toolName: string;
+} | null;
+export declare function mcpToolsToNativeDefinitions(mcpTools: MCPToolDefinition[]): ToolDefinition[];
+export declare function buildMCPServersFromConfig(config: Record<string, MCPServerConfig>): MCPServerConfig[];
+//# sourceMappingURL=bridge.d.ts.map