qlogicagent 2.13.3 → 2.13.5

package/dist/cli/acp-commands.js

@@ -0,0 +1,145 @@
+/**
+ * Single-source slash-command registry for the ACP server.
+ *
+ * `buildAvailableCommands` (the list advertised via `available_commands_update` and summarized by
+ * `/help`) and `dispatchSlashCommand` (execution) share one source of truth — `BUILTIN_COMMANDS`.
+ * Each command's `dispatch` calls the same underlying data service the equivalent RPC handler uses
+ * (model-registry / tool-catalog / skills-query / project-store / acp-detector / memory store) and
+ * formats the result as a text reply. No half-wiring: a command is only listed if it can run.
+ *
+ * Command-set decision (per plan): 9 direct commands + `/init` (degraded to a prompt, no automatic
+ * function). `/compact` is intentionally NOT registered — context compaction is triggered
+ * automatically by reactive-compact, so exposing it as an explicit command would be misleading.
+ * `userInvocable` skill commands are enumerated dynamically; this codebase produces no
+ * `SkillCommandSpec`, so the enumeration is empty (a foreseen degradation, not a stub).
+ */
+import { randomUUID } from "node:crypto";
+import { getModelRegistry } from "../runtime/infra/model-registry.js";
+import { AcpDetector } from "../runtime/infra/acp-detector.js";
+import * as projectStore from "../runtime/infra/project-store.js";
+import { SessionState } from "../runtime/session/session-state.js";
+import { createCliToolCatalog } from "./tool-catalog.js";
+import { listSkillsForProject } from "./skills-query-service.js";
+import { createCliProjectMemoryStoreFactory } from "./project-memory-store-factory.js";
+/** Format a titled bullet list (or a "nothing" line when empty). */
+function fmt(title, rows) {
+    if (rows.length === 0)
+        return `${title}\n• (无)`;
+    return `${title}\n${rows.map((r) => "• " + r).join("\n")}`;
+}
+// ── Data-backed command bodies (call the same services the RPC handlers use) ──────────────────
+function listModels() {
+    const registry = getModelRegistry();
+    const models = registry.listModels();
+    const rows = models.map((m) => `${m.id} (${m.provider}/${m.model})${m.enabled ? "" : " [disabled]"}`);
+    return { handled: true, reply: fmt("可用模型", rows) };
+}
+function setModel(host, modelId) {
+    // Runtime model override — same pin session/set_model writes; the next prompt picks it up.
+    host.sessionLlmConfig.model = modelId;
+    return { handled: true, reply: `已切换运行时模型为 ${modelId}` };
+}
+function listAgents() {
+    const agents = new AcpDetector().scan();
+    const rows = agents.map((a) => `${a.id} — ${a.name} [${a.status}]`);
+    return { handled: true, reply: fmt("可用子 agents", rows) };
+}
+function listSkills(host) {
+    const skills = listSkillsForProject(host.getActiveProjectRoot());
+    const rows = skills.map((s) => `${s.name}${s.active ? "" : " [停用]"}${s.description ? ` — ${s.description}` : ""}`);
+    return { handled: true, reply: fmt("技能", rows) };
+}
+function listTools() {
+    const tools = createCliToolCatalog().getToolManifest(false);
+    const rows = tools.map((t) => `${t.function.name}${t.function.description ? ` — ${t.function.description}` : ""}`);
+    return { handled: true, reply: fmt("可用工具", rows) };
+}
+async function listMemory(host) {
+    const store = createCliProjectMemoryStoreFactory().create(host.getActiveProjectRoot());
+    const files = await store.listFiles();
+    const rows = files.map((f) => `${f.name} (${f.size} bytes)`);
+    return { handled: true, reply: fmt("记忆文件", rows) };
+}
+function listProjects() {
+    const projects = projectStore.listProjects();
+    const rows = projects.map((p) => `${p.id} — ${p.name} [${p.status}]`);
+    return { handled: true, reply: fmt("项目", rows) };
+}
+// ── Registry (single source of truth: list ⇔ execution) ───────────────────────────────────────
+export const BUILTIN_COMMANDS = [
+    {
+        name: "/help",
+        description: "列出所有可用命令(上下文自动压缩,无需手动 /compact)",
+        dispatch: async (host) => ({
+            handled: true,
+            reply: fmt("可用命令", buildAvailableCommands(host).map((c) => `${c.name} — ${c.description ?? ""}`)),
+        }),
+    },
+    {
+        name: "/clear",
+        description: "开始新会话(清空当前上下文)",
+        dispatch: async (host) => {
+            const id = randomUUID();
+            host.currentSessionId = id;
+            host.sessionState = new SessionState(id);
+            return { handled: true, reply: `已开始新会话(${id.slice(0, 8)})` };
+        },
+    },
+    {
+        name: "/cost",
+        description: "显示本会话 token 用量",
+        dispatch: async (host) => {
+            const s = host.sessionState;
+            const i = s?.totalInputTokens ?? 0;
+            const o = s?.totalOutputTokens ?? 0;
+            return { handled: true, reply: `本会话 token — 输入 ${i} / 输出 ${o} / 总计 ${i + o}` };
+        },
+    },
+    {
+        name: "/model",
+        description: "无参列出模型,带参切换运行时模型",
+        dispatch: async (host, args) => (args.trim() ? setModel(host, args.trim()) : listModels()),
+    },
+    { name: "/agents", description: "列出可用子 agents", dispatch: async () => listAgents() },
+    { name: "/skills", description: "列出技能", dispatch: async (host) => listSkills(host) },
+    { name: "/tools", description: "列出可用工具", dispatch: async () => listTools() },
+    { name: "/memory", description: "查看记忆文件", dispatch: async (host) => listMemory(host) },
+    { name: "/project", description: "列出项目", dispatch: async () => listProjects() },
+    {
+        name: "/init",
+        description: "生成项目说明",
+        // Degraded: no automatic function — the model writes the instructions from a natural-language ask.
+        dispatch: async () => ({
+            handled: true,
+            reply: "请用自然语言描述要写入的项目说明(AGENTS.md/instructions),我来生成。",
+        }),
+    },
+    // Note: /compact is intentionally absent — reactive-compact triggers compaction automatically.
+];
+/**
+ * userInvocable skill commands are enumerated from `SkillCommandSpec`. This codebase produces no
+ * such specs, so the enumeration is empty (a foreseen degradation — not a stub). When specs become
+ * available this is the single place to surface them in both the advertised list and dispatch.
+ */
+function enumerateUserInvocableSkillCommands(_host) {
+    return [];
+}
+export function buildAvailableCommands(host) {
+    const builtins = BUILTIN_COMMANDS.map((c) => ({ name: c.name, description: c.description }));
+    const skillCmds = enumerateUserInvocableSkillCommands(host).map((c) => ({ name: c.name, description: c.description }));
+    return [...builtins, ...skillCmds];
+}
+export async function dispatchSlashCommand(host, text, args) {
+    if (!text.startsWith("/"))
+        return { handled: false };
+    const [name, ...inlineArgs] = text.trim().split(/\s+/);
+    const rest = [inlineArgs.join(" "), args].filter(Boolean).join(" ");
+    const builtin = BUILTIN_COMMANDS.find((c) => c.name === name);
+    if (builtin)
+        return builtin.dispatch(host, rest);
+    const skill = enumerateUserInvocableSkillCommands(host).find((c) => c.name === name);
+    if (skill)
+        return skill.dispatch(host, rest);
+    // Unknown /xxx — not a command; let it pass through as a normal prompt.
+    return { handled: false };
+}

package/dist/cli/acp-commands.test.d.ts

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

package/dist/cli/acp-commands.test.js

@@ -0,0 +1,89 @@
+import { describe, expect, it } from "vitest";
+import { buildAvailableCommands, dispatchSlashCommand, BUILTIN_COMMANDS } from "./acp-commands.js";
+function makeHost(overrides = {}) {
+    return {
+        currentSessionId: "s-existing",
+        sessionState: { totalInputTokens: 12, totalOutputTokens: 34 },
+        sessionLlmConfig: {},
+        getActiveProjectRoot: () => process.cwd(),
+        log: () => { },
+        ...overrides,
+    };
+}
+describe("BUILTIN_COMMANDS", () => {
+    it("contains the 9 direct commands plus the degraded /init, and never /compact", () => {
+        const names = BUILTIN_COMMANDS.map((c) => c.name);
+        expect(names).toEqual([
+            "/help",
+            "/clear",
+            "/cost",
+            "/model",
+            "/agents",
+            "/skills",
+            "/tools",
+            "/memory",
+            "/project",
+            "/init",
+        ]);
+        expect(names).not.toContain("/compact");
+    });
+});
+describe("buildAvailableCommands", () => {
+    it("includes builtins (/help, /model, /init) and excludes /compact", () => {
+        const names = buildAvailableCommands(makeHost()).map((c) => c.name);
+        expect(names).toContain("/help");
+        expect(names).toContain("/model");
+        expect(names).toContain("/init");
+        expect(names).not.toContain("/compact");
+    });
+    it("carries a description for every advertised command", () => {
+        for (const c of buildAvailableCommands(makeHost())) {
+            expect(typeof c.description).toBe("string");
+            expect(c.description?.length).toBeGreaterThan(0);
+        }
+    });
+});
+describe("dispatchSlashCommand", () => {
+    it("routes /help to a handled reply that lists the commands", async () => {
+        const r = await dispatchSlashCommand(makeHost(), "/help", "");
+        expect(r.handled).toBe(true);
+        expect(r.reply).toContain("/help");
+        expect(r.reply).toContain("/model");
+    });
+    it("/cost reports the session token usage from sessionState", async () => {
+        const r = await dispatchSlashCommand(makeHost(), "/cost", "");
+        expect(r.handled).toBe(true);
+        expect(r.reply).toContain("12");
+        expect(r.reply).toContain("34");
+        expect(r.reply).toContain("46");
+    });
+    it("/clear resets sessionState and assigns a fresh session id", async () => {
+        const host = makeHost();
+        const before = host.currentSessionId;
+        const r = await dispatchSlashCommand(host, "/clear", "");
+        expect(r.handled).toBe(true);
+        expect(host.currentSessionId).not.toBe(before);
+        expect(host.sessionState).not.toBeNull();
+        expect(host.sessionState.totalInputTokens).toBe(0);
+    });
+    it("/model with an argument sets the runtime model override on the host", async () => {
+        const host = makeHost();
+        const r = await dispatchSlashCommand(host, "/model deepseek-chat", "");
+        expect(r.handled).toBe(true);
+        expect(host.sessionLlmConfig.model).toBe("deepseek-chat");
+        expect(r.reply).toContain("deepseek-chat");
+    });
+    it("/init degrades to a natural-language prompt (no automatic function)", async () => {
+        const r = await dispatchSlashCommand(makeHost(), "/init", "");
+        expect(r.handled).toBe(true);
+        expect(r.reply).toBeTruthy();
+    });
+    it("does not handle a non-slash input", async () => {
+        const r = await dispatchSlashCommand(makeHost(), "你好", "");
+        expect(r.handled).toBe(false);
+    });
+    it("does not handle an unknown slash command (falls through to a normal prompt)", async () => {
+        const r = await dispatchSlashCommand(makeHost(), "/totally-unknown", "");
+        expect(r.handled).toBe(false);
+    });
+});

package/dist/cli/acp-extended-handlers.d.ts

@@ -0,0 +1,69 @@
+import type { SoloSpecChatResult, SoloSpecJudgeResult, WorkflowChatResult } from "../protocol/wire/acp-agent-management.js";
+import { type DreamHandlerHost } from "./handlers/dream-handler.js";
+import { type ProductCoordinatorHost } from "./handlers/product-handler.js";
+import { type SoloHandlerHost } from "./handlers/solo-handler.js";
+import type { LLMTransport } from "./provider-core-facade.js";
+export interface AcpExtendedHost extends DreamHandlerHost, SoloHandlerHost, ProductCoordinatorHost {
+    activeTurn?: AbortController | null;
+    currentSessionId?: string;
+    getActiveProjectRoot(): string;
+    log(message: string): void;
+    resolveClientForPurpose(purpose: "textGeneration"): {
+        transport: LLMTransport;
+        apiKey: string;
+        model: string;
+    } | null;
+    /** Parked ask_user resolvers, keyed by requestId; resolved by thread.user_response. */
+    pendingAskUser: Map<string, {
+        resolve: (answers: Record<string, string> | null) => void;
+    }>;
+}
+export declare function handleAcpDream(host: AcpExtendedHost, params: {
+    sessionId: string;
+    config?: Record<string, unknown>;
+}): Promise<{
+    ok: boolean;
+    summary?: string;
+}>;
+export declare function handleAcpSoloStart(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
+export declare function handleAcpSoloStatus(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
+export declare function handleAcpSoloSelect(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
+export declare function handleAcpSoloCancel(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
+export declare function handleAcpSoloSubscribe(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
+export declare function handleAcpSoloMessage(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
+export declare function handleAcpSoloEvaluate(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
+/**
+ * R3 多轮对话式 spec(x/solo.specChat):每轮带全量 history 跑一次 runSpecChatRound(受限工具
+ * ask_user + set_spec,纯推理不改文件)。澄清走 Cut6 的 turn.ask_user/thread.user_response 往返。
+ * 成功返回 { reply, spec };LLM/连接级失败降级 { error }(不抛,前端可重发)。
+ */
+export declare function handleAcpSoloSpecChat(host: AcpExtendedHost, params: Record<string, unknown>): Promise<SoloSpecChatResult>;
+/**
+ * R3 启动软门防呆(x/solo.specJudge):用 host LLM 一次性评判 spec 是否达可开赛标准。
+ * 无 LLM → 降级放行({ ok:true })(软门本就"警告可走")。返回 { ok, issues[] }。
+ */
+export declare function handleAcpSoloSpecJudge(host: AcpExtendedHost, params: Record<string, unknown>): Promise<SoloSpecJudgeResult>;
+/**
+ * M4 自动化页对话式搭图/改图(x/workflow.chat):forked agent + propose_workflow 工具,产出工作流提案
+ * (新建 def / 改已有 patch),propose-only 无副作用。澄清走 Cut6 ask 往返。失败降级 { error } 不抛。
+ * 应用由前端经既有 workflow.create/patch 完成(触发 WS 回流画布),故本轮不碰引擎控制器。
+ */
+export declare function handleAcpWorkflowChat(host: AcpExtendedHost, params: Record<string, unknown>): Promise<WorkflowChatResult>;
+export declare function handleAcpAgentsList(host: AcpExtendedHost): Promise<unknown>;
+/**
+ * x/workflow.matchIntent(spec D22 语义兜底)— 确定性短语在客户端已查过且未命中,且存在
+ * semantic:true 的活跃意图工作流时才会被调用:对候选集做**一次**轻量 LLM 分类(单发,非 agent
+ * turn)。候选枚举是纯文件读(active root + automation 项目的工作流 store),不经引擎。
+ * 无 LLM / 分类失败 → {matched:null}(放行进正常聊天,绝不拦死用户消息)。
+ */
+export declare function handleAcpWorkflowMatchIntent(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
+export declare function handleAcpProductCreate(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
+export declare function handleAcpProductPlan(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
+export declare function handleAcpProductConfirm(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
+export declare function handleAcpProductMessage(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
+export declare function handleAcpProductResume(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
+export declare function handleAcpProductStatus(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
+export declare function handleAcpProductPause(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
+export declare function handleAcpProductCancel(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
+export declare function handleAcpProductRollback(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
+export declare function handleAcpProductSubscribe(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;