@qlingzzy/qling 1.0.0

package/dist/commands/hooks.js

@@ -0,0 +1,14 @@
+import { guardConfigFromEnv } from "../config.js";
+import { buildLocalHooksReport, formatLocalHooksReport } from "../hooks-report.js";
+export const hooksCommand = {
+    name: "/hooks",
+    aliases: ["/钩子"],
+    description: "查看本地 hooks/guard 配置摘要",
+    usage: "/hooks",
+    execute: async (_args, context) => {
+        const report = buildLocalHooksReport(guardConfigFromEnv(process.env));
+        for (const line of formatLocalHooksReport(report)) {
+            context.writeLine(line);
+        }
+    },
+};

package/dist/commands/index.d.ts

@@ -0,0 +1,29 @@
+import { SlashCommand } from "./types.js";
+import { SlashCommandContext } from "./runtime.js";
+export declare const COMMANDS: SlashCommand[];
+interface SlashSuggestion {
+    command: string;
+    topic: string;
+    score: number;
+}
+export interface SlashCommandCatalogItem {
+    name: string;
+    aliases: string[];
+    description: string;
+    usage: string;
+    category: string;
+    argumentHint: string;
+    availability: "local" | "unsupported";
+    examples: string[];
+    claudeCompatibleName?: string;
+}
+export declare function getSlashCommandCatalog(): SlashCommandCatalogItem[];
+export declare function findSlashCommandSuggestions(input: string, limit?: number): SlashSuggestion[];
+export declare function findSlashCompletion(prefix: string, limit?: number): SlashCommandCatalogItem[];
+export declare function formatSlashCompletionHint(prefix: string, width?: number): string[];
+export declare function formatSlashCommandPanel(prefix: string, selectedIndex?: number, width?: number, limit?: number): string[];
+export declare function formatGroupedSlashPanel(width?: number): string[];
+export declare function formatUnknownSlashCommandMessage(cmdName: string): string;
+export declare function handleSlashCommand(input: string, contextOrAgentLoop: SlashCommandContext | Record<string, any>): Promise<boolean>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/commands/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAoC1C,OAAO,EAAE,mBAAmB,EAAsB,MAAM,cAAc,CAAC;AAqBvE,eAAO,MAAM,QAAQ,EAAE,YAAY,EA8ClC,CAAC;AAMF,UAAU,eAAe;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,OAAO,GAAG,aAAa,CAAC;IACtC,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAyDD,wBAAgB,sBAAsB,IAAI,uBAAuB,EAAE,CAalE;AA4CD,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,SAAI,GAAG,eAAe,EAAE,CAsBvF;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,SAAI,GAAG,uBAAuB,EAAE,CAyBxF;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,SAAK,GAAG,MAAM,EAAE,CAO9E;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,EAAE,aAAa,SAAI,EAAE,KAAK,SAAK,EAAE,KAAK,SAAI,GAAG,MAAM,EAAE,CAyB1G;AAoBD,wBAAgB,uBAAuB,CAAC,KAAK,SAAK,GAAG,MAAM,EAAE,CAwC5D;AASD,wBAAgB,gCAAgC,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAuBxE;AAED,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,MAAM,EACb,kBAAkB,EAAE,mBAAmB,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAC5D,OAAO,CAAC,OAAO,CAAC,CAgClB"}

package/dist/commands/index.js

@@ -0,0 +1,417 @@
+import { helpCommand } from "./help.js";
+import { clearCommand } from "./clear.js";
+import { statusCommand } from "./status.js";
+import { skillCommand } from "./skill.js";
+import { dashboardCommand } from "./dashboard.js";
+import { configCommand } from "./config.js";
+import { detachCommand } from "./detach.js";
+import { compactCommand } from "./compact.js";
+import { goalCommand } from "./goal.js";
+import { loopCommand } from "./loop.js";
+import { tasksCommand } from "./tasks.js";
+import { sessionsCommand } from "./sessions.js";
+import { resumeCommand } from "./resume.js";
+import { checkpointCommand } from "./checkpoint.js";
+import { permissionsCommand } from "./permissions.js";
+import { statuslineCommand } from "./statusline.js";
+import { doctorCommand } from "./doctor.js";
+import { contextCommand } from "./context.js";
+import { recapCommand } from "./recap.js";
+import { privacyCommand } from "./privacy.js";
+import { shortcutsCommand } from "./shortcuts.js";
+import { exportCommand } from "./export.js";
+import { exportsCommand } from "./exports.js";
+import { memoryCommand } from "./memory.js";
+import { repomapCommand } from "./repomap.js";
+import { dreamCommand } from "./dream.js";
+import { distillCommand } from "./distill.js";
+import { knowledgeCommand } from "./knowledge.js";
+import { connectCommand } from "./connect.js";
+import { storageCommand } from "./storage.js";
+import { mcpCommand } from "./mcp.js";
+import { hooksCommand } from "./hooks.js";
+import { agentsCommand } from "./agents.js";
+import { missionCommand } from "./mission.js";
+import { verifyCommand } from "./verify.js";
+import { withDefaultWriters } from "./runtime.js";
+import { formatFocusedHelp } from "../help-topics.js";
+import { formatLocalGuidancePanel } from "../cli/guidance-panel.js";
+import { getLocalizedText } from "../i18n/index.js";
+import { commitCommand, copyCommand, diffCommand, expandCommand, initCommand, modelCommand, planCommand, rewindCommand, unavailableClaudeCommands, usageCommand, } from "./claude-style.js";
+import { getSkillDirs, runSkill } from "../tools/skill.js";
+import { listSkills } from "../skills/registry.js";
+import { existsSync, readdirSync } from "fs";
+import { basename } from "path";
+export const COMMANDS = [
+    helpCommand,
+    initCommand,
+    sessionsCommand,
+    resumeCommand,
+    rewindCommand,
+    checkpointCommand,
+    clearCommand,
+    statusCommand,
+    usageCommand,
+    modelCommand,
+    planCommand,
+    expandCommand,
+    diffCommand,
+    commitCommand,
+    copyCommand,
+    skillCommand,
+    dashboardCommand,
+    configCommand,
+    detachCommand,
+    compactCommand,
+    goalCommand,
+    loopCommand,
+    tasksCommand,
+    permissionsCommand,
+    statuslineCommand,
+    recapCommand,
+    privacyCommand,
+    shortcutsCommand,
+    exportCommand,
+    exportsCommand,
+    memoryCommand,
+    repomapCommand,
+    knowledgeCommand,
+    connectCommand,
+    verifyCommand,
+    dreamCommand,
+    distillCommand,
+    storageCommand,
+    agentsCommand,
+    missionCommand,
+    mcpCommand,
+    hooksCommand,
+    doctorCommand,
+    contextCommand,
+    ...unavailableClaudeCommands,
+];
+function isCommandContext(value) {
+    return Boolean(value && typeof value === "object" && "agentLoop" in value);
+}
+function normalizeSlashName(value) {
+    return value.trim().replace(/^\/+/, "").toLowerCase();
+}
+function isSlashHelpFlag(value) {
+    return value === "--help" || value === "-h";
+}
+function writeFocusedSlashHelp(topic, context) {
+    for (const line of formatFocusedHelp(topic, { surface: "slash" })) {
+        context.writeLine(line);
+    }
+}
+function levenshteinDistance(left, right) {
+    if (left === right)
+        return 0;
+    if (!left)
+        return right.length;
+    if (!right)
+        return left.length;
+    let previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+    for (let i = 0; i < left.length; i++) {
+        const current = [i + 1];
+        for (let j = 0; j < right.length; j++) {
+            const substitutionCost = left[i] === right[j] ? 0 : 1;
+            current[j + 1] = Math.min(current[j] + 1, previous[j + 1] + 1, previous[j] + substitutionCost);
+        }
+        previous = current;
+    }
+    return previous[right.length];
+}
+function scoreSlashCandidate(input, candidate) {
+    const normalizedInput = normalizeSlashName(input);
+    const normalizedCandidate = normalizeSlashName(candidate);
+    if (!normalizedInput || !normalizedCandidate)
+        return null;
+    if (normalizedCandidate === normalizedInput)
+        return 100;
+    if (normalizedCandidate.startsWith(normalizedInput) || normalizedInput.startsWith(normalizedCandidate)) {
+        return 80 - Math.abs(normalizedCandidate.length - normalizedInput.length);
+    }
+    if (normalizedCandidate.includes(normalizedInput) || normalizedInput.includes(normalizedCandidate)) {
+        return 60 - Math.abs(normalizedCandidate.length - normalizedInput.length);
+    }
+    const distance = levenshteinDistance(normalizedInput, normalizedCandidate);
+    const maxLength = Math.max(normalizedInput.length, normalizedCandidate.length);
+    const allowedDistance = maxLength <= 5 ? 1 : 2;
+    if (distance > allowedDistance)
+        return null;
+    const endingBoost = normalizedInput.endsWith("s") && normalizedCandidate.endsWith("s") ? 12 : 0;
+    return 45 - distance * 8 - Math.abs(normalizedCandidate.length - normalizedInput.length) + endingBoost;
+}
+export function getSlashCommandCatalog() {
+    const commands = COMMANDS.map((command) => ({
+        name: command.name,
+        aliases: [...(command.aliases ?? [])],
+        description: command.description,
+        usage: command.usage,
+        category: command.category ?? "local",
+        argumentHint: command.argumentHint ?? "",
+        availability: command.availability ?? "local",
+        examples: [...(command.examples ?? [])],
+        claudeCompatibleName: command.claudeCompatibleName,
+    }));
+    return [...commands, ...getLocalSkillCatalogItems(commands)];
+}
+function getSlashCommandNames(item) {
+    return [item.name, ...item.aliases];
+}
+function getLocalSkillCatalogItems(existing) {
+    const builtinNames = new Set(existing.flatMap(getSlashCommandNames).map(normalizeSlashName));
+    const items = [];
+    for (const dir of getSkillDirs()) {
+        if (!existsSync(dir))
+            continue;
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const skillName = entry.isDirectory()
+                ? entry.name
+                : entry.isFile() && entry.name.toLowerCase().endsWith(".md")
+                    ? basename(entry.name, ".md")
+                    : "";
+            const normalized = normalizeSlashName(skillName);
+            if (!normalized || normalized === "skill" || normalized === "index")
+                continue;
+            if (builtinNames.has(normalized))
+                continue;
+            const slashName = `/${skillName}`;
+            if (items.some((item) => item.name === slashName))
+                continue;
+            items.push({
+                name: slashName,
+                aliases: [],
+                description: "本地 skill 直接调用",
+                usage: slashName,
+                category: "skill",
+                argumentHint: "",
+                availability: "local",
+                examples: [slashName, `/skill ${skillName}`],
+            });
+        }
+    }
+    return items;
+}
+export function findSlashCommandSuggestions(input, limit = 3) {
+    const suggestions = [];
+    for (const item of getSlashCommandCatalog()) {
+        for (const name of getSlashCommandNames(item)) {
+            const score = scoreSlashCandidate(input, name);
+            if (score === null || score < 20)
+                continue;
+            suggestions.push({
+                command: name,
+                topic: normalizeSlashName(name),
+                score,
+            });
+        }
+    }
+    return suggestions
+        .sort((left, right) => right.score - left.score
+        || normalizeSlashName(right.command).length - normalizeSlashName(left.command).length
+        || left.command.localeCompare(right.command))
+        .filter((suggestion, index, sorted) => sorted.findIndex((item) => item.command === suggestion.command) === index)
+        .slice(0, limit);
+}
+export function findSlashCompletion(prefix, limit = 5) {
+    const rawPrefix = prefix.trim();
+    if (!rawPrefix.startsWith("/") || /\s/.test(rawPrefix))
+        return [];
+    const normalizedPrefix = normalizeSlashName(rawPrefix);
+    const catalog = getSlashCommandCatalog();
+    const matched = catalog
+        .map((item, index) => {
+        const names = getSlashCommandNames(item);
+        const bestScore = names.reduce((best, name) => {
+            const normalizedName = normalizeSlashName(name);
+            if (!normalizedName)
+                return best;
+            if (!normalizedPrefix)
+                return Math.max(best, 1);
+            if (normalizedName === normalizedPrefix)
+                return Math.max(best, 100);
+            if (normalizedName.startsWith(normalizedPrefix)) {
+                return Math.max(best, 80 - Math.abs(normalizedName.length - normalizedPrefix.length));
+            }
+            return best;
+        }, 0);
+        return { item, index, score: bestScore };
+    })
+        .filter((entry) => entry.score > 0)
+        .sort((left, right) => right.score - left.score || left.index - right.index)
+        .map((entry) => entry.item);
+    return matched.slice(0, Math.max(0, limit));
+}
+export function formatSlashCompletionHint(prefix, width = 80) {
+    const matches = findSlashCompletion(prefix, 5);
+    if (matches.length === 0)
+        return [];
+    const commandList = matches.map((item) => item.name).join("  ");
+    const line = `补全    : ${commandList}    Tab 补全`;
+    const safeWidth = Math.max(30, Math.floor(Number(width) || 80));
+    return [line.length > safeWidth ? line.slice(0, safeWidth - 1) + "…" : line];
+}
+export function formatSlashCommandPanel(prefix, selectedIndex = 0, width = 80, limit = 8) {
+    const t = getLocalizedText();
+    const matches = findSlashCompletion(prefix, limit);
+    const safeWidth = Math.max(30, Math.floor(Number(width) || 80));
+    if (matches.length > 0) {
+        const lines = matches.map((item, index) => {
+            const marker = index === selectedIndex ? ">" : " ";
+            const args = item.argumentHint ? ` ${item.argumentHint}` : "";
+            const cat = item.category || "local";
+            const cnCat = getChineseCategory(cat, t);
+            return truncatePanelLine(`${marker} ${item.name}${args}  [${cnCat}]  ${item.description}`, safeWidth);
+        });
+        const panelHint = t.tui?.hints?.panel || "提示    : ↑/↓ 选择 · Tab 补全 · Enter 执行当前输入";
+        lines.push(truncatePanelLine(panelHint, safeWidth));
+        return lines;
+    }
+    const hint = findExactSlashCommandForArgumentHint(prefix);
+    if (!hint)
+        return [];
+    const arg = hint.argumentHint || hint.usage.replace(hint.name, "").trim();
+    const contHint = t.tui?.hints?.continueInput || "提示    : 继续输入参数 · Enter 执行当前输入";
+    return [
+        truncatePanelLine(`参数    : ${hint.name}${arg ? ` ${arg}` : ""}    ${hint.description}`, safeWidth),
+        truncatePanelLine(contHint, safeWidth),
+    ];
+}
+function truncatePanelLine(line, width) {
+    return line.length > width ? line.slice(0, width - 1) + "…" : line;
+}
+function getChineseCategory(cat, t) {
+    const cats = t.tui?.slashCategories || {};
+    const map = {
+        local: cats.common || "常用",
+        core: cats.common || "常用",
+        session: cats.context || "上下文",
+        git: cats.git || "Git",
+        memory: cats.memory || "记忆",
+        cloud: cats.connectors || "连接器",
+        skill: cats.advanced || "高级",
+    };
+    return cats[cat] || map[cat] || cat;
+}
+export function formatGroupedSlashPanel(width = 80) {
+    const t = getLocalizedText();
+    const catalog = getSlashCommandCatalog();
+    const safeWidth = Math.max(30, Math.floor(Number(width) || 80));
+    const groups = {};
+    for (const item of catalog) {
+        const cat = item.category || "local";
+        if (!groups[cat])
+            groups[cat] = [];
+        groups[cat].push(item);
+    }
+    const order = ["local", "core", "session", "git", "memory", "cloud", "skill"];
+    const lines = [];
+    const panelHint = t.tui?.hints?.panel || "提示    : ↑/↓ 选择 · Tab 补全 · Enter 执行当前输入";
+    const merged = {};
+    for (const key of order) {
+        const items = groups[key];
+        if (!items || items.length === 0)
+            continue;
+        const cn = getChineseCategory(key, t);
+        if (!merged[cn])
+            merged[cn] = [];
+        merged[cn].push(...items);
+    }
+    lines.push(truncatePanelLine("轻灵命令面板 (按 / + Tab 过滤)", safeWidth));
+    lines.push(truncatePanelLine("─".repeat(Math.min(safeWidth, 60)), safeWidth));
+    for (const [cn, items] of Object.entries(merged)) {
+        lines.push(truncatePanelLine(`【${cn}】`, safeWidth));
+        for (const item of items.slice(0, 5)) {
+            const args = item.argumentHint ? ` ${item.argumentHint}` : "";
+            const desc = item.description.length > 30 ? item.description.slice(0, 28) + "…" : item.description;
+            lines.push(truncatePanelLine(`  ${item.name}${args}  ${desc}`, safeWidth));
+        }
+    }
+    lines.push(truncatePanelLine("─".repeat(Math.min(safeWidth, 60)), safeWidth));
+    lines.push(truncatePanelLine(panelHint, safeWidth));
+    return lines;
+}
+function findExactSlashCommandForArgumentHint(input) {
+    if (!input.startsWith("/") || !/\s$/.test(input))
+        return null;
+    const cmd = input.trim().split(/\s+/)[0] ?? "";
+    if (!cmd)
+        return null;
+    return getSlashCommandCatalog().find((item) => getSlashCommandNames(item).some((name) => name === cmd)) ?? null;
+}
+export function formatUnknownSlashCommandMessage(cmdName) {
+    const t = getLocalizedText();
+    const suggestions = findSlashCommandSuggestions(cmdName);
+    const normalizedInput = cmdName.replace(/^\/+/, "");
+    if (!suggestions.length) {
+        return formatLocalGuidancePanel({
+            title: `❌ 未知指令: ${cmdName}。`,
+            reason: "当前输入不是已注册的 slash 命令。",
+            next: "查看全部: /help",
+            example: `普通输入: ${normalizedInput}`,
+            boundary: t.boundaries.slashCorrection,
+        });
+    }
+    const commands = suggestions.map((suggestion) => suggestion.command).join(", ");
+    const primary = suggestions[0];
+    return formatLocalGuidancePanel({
+        title: `❌ 未知指令: ${cmdName}。`,
+        reason: "输入看起来像 slash 命令，但没有精确命中命令目录。",
+        next: `你是不是想用: ${commands}；可执行: ${primary.command}`,
+        example: `查看用法: /help ${primary.topic}；普通输入: ${normalizedInput}`,
+        boundary: t.boundaries.slashCorrection,
+    });
+}
+export async function handleSlashCommand(input, contextOrAgentLoop) {
+    if (!input.startsWith("/"))
+        return false;
+    const context = isCommandContext(contextOrAgentLoop)
+        ? withDefaultWriters(contextOrAgentLoop)
+        : withDefaultWriters({ agentLoop: contextOrAgentLoop });
+    const parts = input.split(/\s+/);
+    const cmdName = parts[0].toLowerCase();
+    const args = parts.slice(1);
+    const hasHelpFlag = args.some(isSlashHelpFlag);
+    const cmd = COMMANDS.find(c => c.name === cmdName || c.aliases?.includes(cmdName));
+    if (cmd) {
+        if (cmd.name !== helpCommand.name && hasHelpFlag) {
+            writeFocusedSlashHelp(normalizeSlashName(cmd.name), context);
+            return true;
+        }
+        await cmd.execute(args, context);
+        return true;
+    }
+    if (await tryRunDirectSkill(cmdName, context)) {
+        return true;
+    }
+    if (hasHelpFlag) {
+        writeFocusedSlashHelp(normalizeSlashName(cmdName), context);
+        return true;
+    }
+    context.writeError(formatUnknownSlashCommandMessage(cmdName));
+    return true;
+}
+async function tryRunDirectSkill(cmdName, context) {
+    const name = normalizeSlashName(cmdName);
+    if (!/^[a-z0-9_@/-]+$/i.test(name))
+        return false;
+    const skills = await listSkills(getSkillDirs());
+    if (!skills.some((skill) => normalizeSlashName(skill.name) === name))
+        return false;
+    const result = await runSkill({ name });
+    if (result.is_error) {
+        context.writeError(result.output);
+    }
+    else {
+        context.writeLine(result.output);
+    }
+    return true;
+}

package/dist/commands/knowledge.d.ts

@@ -0,0 +1,8 @@
+import { SlashCommand } from "./types.js";
+export declare function chineseChunk(text: string, maxLen?: number): string[];
+export declare function simpleIndex(dir: string, maxFiles?: number): {
+    file: string;
+    chunks: string[];
+}[];
+export declare const knowledgeCommand: SlashCommand;
+//# sourceMappingURL=knowledge.d.ts.map

package/dist/commands/knowledge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge.d.ts","sourceRoot":"","sources":["../../src/commands/knowledge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AA+B1C,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,SAAM,GAAG,MAAM,EAAE,CAoBjE;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,SAAK,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,EAAE,CAyB5F;AAED,eAAO,MAAM,gBAAgB,EAAE,YAkH9B,CAAC"}

package/dist/commands/knowledge.js

@@ -0,0 +1,191 @@
+import { join } from "path";
+import { readdirSync, readFileSync, statSync } from "fs";
+import { searchLocalMemoryEntries, } from "../memory-report.js";
+function resolveStateDirForKnowledge(context) {
+    const agentLoop = context?.agentLoop;
+    if (agentLoop?.getRuntimeRootDir) {
+        try {
+            const root = agentLoop.getRuntimeRootDir();
+            if (root)
+                return root;
+        }
+        catch { }
+    }
+    const envDir = process.env.QLING_FILE_STATE_DIR;
+    if (envDir)
+        return envDir;
+    const ctxState = context?.stateDir || context?.workspaceDir;
+    if (ctxState)
+        return ctxState;
+    return join(require("os").homedir(), ".qling");
+}
+// P3 完善：中文知识库/RAG 最小闭环
+// - 中文友好 chunk（按句/段落）
+// - 本地文件索引（递归简单扫描）
+// - 搜索 + 引用展示（置信度 + 来源片段）
+// - 推荐中文模型
+// 复用 memory 搜索能力；无重型向量DB
+export function chineseChunk(text, maxLen = 400) {
+    const chunks = [];
+    // 优先按段落，其次中文句子
+    let parts = text.split(/\n\s*\n/);
+    if (parts.length < 2) {
+        parts = text.split(/[。！？；\n]+/).filter(Boolean);
+    }
+    let current = "";
+    for (const p of parts) {
+        const s = p.trim();
+        if (!s)
+            continue;
+        if ((current + s).length > maxLen && current) {
+            chunks.push(current.trim());
+            current = s + "。";
+        }
+        else {
+            current += (current ? " " : "") + s + "。";
+        }
+    }
+    if (current.trim())
+        chunks.push(current.trim());
+    return chunks.length ? chunks : [text.slice(0, maxLen)];
+}
+export function simpleIndex(dir, maxFiles = 20) {
+    const results = [];
+    try {
+        const entries = readdirSync(dir);
+        let count = 0;
+        for (const e of entries) {
+            if (count >= maxFiles)
+                break;
+            const full = join(dir, e);
+            try {
+                const st = statSync(full);
+                if (st.isDirectory()) {
+                    // 递归一层
+                    const sub = simpleIndex(full, Math.max(1, maxFiles - count));
+                    results.push(...sub);
+                    count += sub.length;
+                }
+                else if (/\.(md|txt|ts|js|py|json)$/i.test(e)) {
+                    const content = readFileSync(full, "utf8").slice(0, 8000);
+                    const chunks = chineseChunk(content);
+                    results.push({ file: e, chunks });
+                    count++;
+                }
+            }
+            catch { }
+        }
+    }
+    catch { }
+    return results;
+}
+export const knowledgeCommand = {
+    name: "/knowledge",
+    aliases: ["/知", "/kb", "/rag"],
+    description: "本地知识库搜索（中文友好 chunk + 引用）",
+    usage: "/knowledge <查询> | /knowledge index <路径>",
+    execute: async (args, context) => {
+        const sub = (args[0] || "").toLowerCase();
+        const queryParts = args.slice(1);
+        const query = queryParts.join(" ").trim();
+        const t = context.i18n || null; // 未来可接 i18n
+        context.writeLine("");
+        context.writeLine("📚 【轻灵知识库】本地优先 · 中文 RAG");
+        context.writeLine("-----------------------------------------");
+        if (!query && sub !== "index" && sub !== "索引") {
+            context.writeLine("用法: /knowledge <问题>   或  /knowledge index <目录>");
+            context.writeLine("默认模型推荐: DeepSeek / Qwen / GLM + 中文 embedding");
+            context.writeLine("边界: 仅本地索引，不上传，不默认联网。");
+            context.writeLine("-----------------------------------------");
+            context.writeLine("");
+            return;
+        }
+        const agentLoop = context.agentLoop;
+        const memoryStore = agentLoop?.getMemoryStore?.();
+        if (sub === "embed" || sub === "embedding" || sub === "调优") {
+            context.writeLine("Embedding 调优 (P3 RAG 细节):");
+            context.writeLine(`当前推荐模型: ${process.env.QLING_MEMORY_SEMANTIC_MODEL || "text-embedding-3-small"}`);
+            context.writeLine("可用调优: 设置 QLING_MEMORY_SEMANTIC_MODEL=你的模型");
+            context.writeLine("维度: dimensions 可在 EmbeddingClient 配置");
+            context.writeLine("测试: /knowledge embed test <文本>");
+            context.writeLine("边界: 需要 API key 和支持 embeddings 的 endpoint");
+            return;
+        }
+        if (sub === "index" || sub === "索引") {
+            const target = query || process.cwd();
+            context.writeLine(`正在索引: ${target} （中文 chunk 策略：按句/段落，max~400字）`);
+            const indexed = simpleIndex(target);
+            let totalChunks = 0;
+            for (const item of indexed) {
+                totalChunks += item.chunks.length;
+                if (memoryStore && item.chunks.length) {
+                    try {
+                        for (const ch of item.chunks.slice(0, 3)) {
+                            memoryStore.add(`[知识库] ${item.file}: ${ch}`, "knowledge", 0.75, false);
+                        }
+                    }
+                    catch { }
+                }
+            }
+            if (memoryStore && typeof memoryStore.saveToDisk === "function") {
+                try {
+                    await memoryStore.saveToDisk();
+                }
+                catch { }
+            }
+            context.writeLine(`索引完成：${indexed.length} 个文件，${totalChunks} 个 chunk。`);
+            context.writeLine("已尝试合并到本地 memory。使用 /knowledge <问题> 查询。");
+        }
+        else {
+            context.writeLine(`查询: ${query}`);
+            context.writeLine("结果 (引用片段 + 置信):");
+            let usedRealSearch = false;
+            const stateDir = resolveStateDirForKnowledge(context);
+            if (stateDir) {
+                try {
+                    const report = await searchLocalMemoryEntries(stateDir, { query, count: 5 });
+                    if (report.entries && report.entries.length > 0) {
+                        usedRealSearch = true;
+                        report.entries.forEach((e, i) => {
+                            const src = e.source || "memory";
+                            const conf = (e.score ?? 0.7).toFixed(2);
+                            const snippet = (e.content || e.preview || "").slice(0, 120).replace(/\n/g, " ");
+                            const chain = e.metadata?.chain || e.source || src;
+                            context.writeLine(`  ${i + 1}. [${src}] ${snippet}... (置信 ${conf}) 链路: ${chain}`);
+                        });
+                    }
+                }
+                catch { }
+            }
+            if (!usedRealSearch && memoryStore && typeof memoryStore.search === "function") {
+                try {
+                    const hits = await memoryStore.search(query, 5) || [];
+                    if (hits.length) {
+                        usedRealSearch = true;
+                        hits.slice(0, 5).forEach((h, i) => {
+                            const src = h.source || "memory";
+                            const conf = (h.score ?? h.confidence ?? 0.7).toFixed(2);
+                            const snippet = (h.content || h.entry?.content || "").slice(0, 120).replace(/\n/g, " ");
+                            const chain = h.metadata?.chain || h.source || src;
+                            context.writeLine(`  ${i + 1}. [${src}] ${snippet}... (置信 ${conf}) 链路: ${chain}`);
+                        });
+                    }
+                }
+                catch { }
+            }
+            if (!usedRealSearch) {
+                // 演示友好回退 + 模拟 chunk 结果
+                const demoChunks = chineseChunk("本地知识库示例：轻灵支持中文 chunk，按段落或标点切分。推荐搭配 Qwen/DeepSeek 使用本地 embedding。");
+                context.writeLine(`  1. [demo-chunk] ${demoChunks[0].slice(0, 100)}... (置信 0.65)`);
+                context.writeLine("  (提示：运行 /knowledge index . 建立真实索引后重试；启用 semantic_memory 获得真实向量搜索)");
+            }
+            context.writeLine("");
+            context.writeLine("引用: 以上来自本机 memory / 文件索引。");
+            context.writeLine("建议模型: Qwen / DeepSeek / GLM (中文理解强) + Ollama 离线");
+            context.writeLine("提示: 设置 QLING_FEATURES_SEMANTIC_MEMORY=true 可启用真实 semantic search");
+        }
+        context.writeLine("-----------------------------------------");
+        context.writeLine("离线/私有化: Ollama + 本地 embedding 完全可行。无云上传。");
+        context.writeLine("");
+    },
+};

package/dist/commands/loop.d.ts

@@ -0,0 +1,3 @@
+import { SlashCommand } from "./types.js";
+export declare const loopCommand: SlashCommand;
+//# sourceMappingURL=loop.d.ts.map

package/dist/commands/loop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loop.d.ts","sourceRoot":"","sources":["../../src/commands/loop.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAiC1C,eAAO,MAAM,WAAW,EAAE,YAgGzB,CAAC"}