cli-claw-kit 0.0.1

package/dist/runtime-command-handler.js

@@ -0,0 +1,189 @@
+import { formatCommandHelp, getModelPresets, getReasoningEffortPresets, normalizeModelPreset, normalizeReasoningEffortPreset, parseRuntimeCommand, supportsReasoningEffort, } from './runtime-command-registry.js';
+import { buildEffectiveGroupFromHomeSibling } from './group-runtime.js';
+import { resetWorkspaceRuntimeState } from './workspace-runtime-reset.js';
+function stripVirtualChatJid(chatJid) {
+    const agentIdx = chatJid.indexOf('#agent:');
+    if (agentIdx >= 0)
+        return chatJid.slice(0, agentIdx);
+    return chatJid;
+}
+function normalizeAgentType(value) {
+    return value === 'codex' ? 'codex' : 'claude';
+}
+function resolveLegacyMainJid(targetMainJid, deps) {
+    if (deps.getGroup(targetMainJid))
+        return targetMainJid;
+    if (!targetMainJid.startsWith('web:'))
+        return targetMainJid;
+    const folder = targetMainJid.slice(4);
+    for (const jid of deps.getSiblingJids(folder)) {
+        if (jid.startsWith('web:') && deps.getGroup(jid))
+            return jid;
+    }
+    return targetMainJid;
+}
+function findHomeWorkspaceJid(group, deps) {
+    const siblingJids = deps.getSiblingJids(group.folder);
+    let fallbackHomeJid = null;
+    for (const jid of siblingJids) {
+        const sibling = deps.getGroup(jid);
+        if (!sibling?.is_home)
+            continue;
+        if (jid.startsWith('web:'))
+            return jid;
+        fallbackHomeJid = fallbackHomeJid ?? jid;
+    }
+    return fallbackHomeJid;
+}
+function resolveWorkspaceJid(sourceChatJid, sourceGroup, deps) {
+    if (sourceGroup.target_agent_id) {
+        const agent = deps.getAgent(sourceGroup.target_agent_id);
+        if (agent?.chat_jid)
+            return agent.chat_jid;
+    }
+    if (sourceGroup.target_main_jid) {
+        return resolveLegacyMainJid(sourceGroup.target_main_jid, deps);
+    }
+    if (sourceChatJid.startsWith('web:')) {
+        return sourceChatJid;
+    }
+    return findHomeWorkspaceJid(sourceGroup, deps) ?? sourceChatJid;
+}
+function resolveEffectiveRuntimeGroup(workspaceGroup, deps) {
+    if (workspaceGroup.is_home)
+        return workspaceGroup;
+    const homeJid = findHomeWorkspaceJid(workspaceGroup, deps);
+    if (!homeJid)
+        return workspaceGroup;
+    const homeGroup = deps.getGroup(homeJid);
+    if (!homeGroup)
+        return workspaceGroup;
+    return buildEffectiveGroupFromHomeSibling(workspaceGroup, homeGroup);
+}
+export function resolveRuntimeWorkspaceTarget(chatJid, deps) {
+    const sourceChatJid = stripVirtualChatJid(chatJid);
+    const sourceGroup = deps.getGroup(sourceChatJid);
+    if (!sourceGroup)
+        return null;
+    const workspaceJid = resolveWorkspaceJid(sourceChatJid, sourceGroup, deps);
+    const workspaceGroup = deps.getGroup(workspaceJid) ?? sourceGroup;
+    const effectiveGroup = resolveEffectiveRuntimeGroup(workspaceGroup, deps);
+    return {
+        sourceChatJid,
+        sourceGroup,
+        workspaceJid,
+        workspaceGroup,
+        effectiveGroup,
+    };
+}
+function formatRuntimeScopeLabel(target) {
+    return target.workspaceGroup.name || target.effectiveGroup.folder;
+}
+function buildHelpReply(entrypoint, target) {
+    const agentType = normalizeAgentType(target.effectiveGroup.agentType);
+    const modelPresets = getModelPresets(agentType).join(', ');
+    const effortPresets = supportsReasoningEffort(agentType)
+        ? getReasoningEffortPresets().join(', ')
+        : null;
+    const currentModel = target.workspaceGroup.model ?? '默认';
+    const currentEffort = supportsReasoningEffort(agentType)
+        ? (target.workspaceGroup.reasoningEffort ?? '默认')
+        : null;
+    const lines = [
+        `当前工作区: ${formatRuntimeScopeLabel(target)}`,
+        `当前 runtime: ${agentType}`,
+        `当前模型: ${currentModel}`,
+    ];
+    if (currentEffort) {
+        lines.push(`当前思考强度: ${currentEffort}`);
+    }
+    lines.push(`模型预设: ${modelPresets}`);
+    if (effortPresets) {
+        lines.push(`思考强度预设: ${effortPresets}`);
+    }
+    lines.push('');
+    lines.push(formatCommandHelp({
+        entrypoint,
+        agentType,
+    }));
+    return lines.join('\n');
+}
+async function updateWorkspaceRuntime(target, deps, patch) {
+    const updated = {
+        ...target.workspaceGroup,
+        ...patch,
+    };
+    deps.setGroup(target.workspaceJid, updated);
+    await resetWorkspaceRuntimeState({
+        queue: deps.queue,
+        getSessions: deps.getSessions,
+    }, target.workspaceJid, updated);
+}
+async function handleModelCommand(target, deps, rawPreset) {
+    const agentType = normalizeAgentType(target.effectiveGroup.agentType);
+    const preset = normalizeModelPreset(agentType, rawPreset);
+    if (!preset) {
+        return `不支持的 ${agentType} 模型预设。可用值：${getModelPresets(agentType).join(', ')}`;
+    }
+    if ((target.workspaceGroup.model ?? null) === preset) {
+        return `当前工作区模型已经是 ${preset}`;
+    }
+    await updateWorkspaceRuntime(target, deps, { model: preset });
+    return `已将当前工作区模型切换为 ${preset}`;
+}
+async function handleEffortCommand(target, deps, rawPreset) {
+    const agentType = normalizeAgentType(target.effectiveGroup.agentType);
+    if (!supportsReasoningEffort(agentType)) {
+        return `${agentType} 不支持 /effort，可继续使用 /model 切换模型`;
+    }
+    const preset = normalizeReasoningEffortPreset(rawPreset);
+    if (!preset) {
+        return `不支持的思考强度预设。可用值：${getReasoningEffortPresets().join(', ')}`;
+    }
+    if ((target.workspaceGroup.reasoningEffort ?? null) === preset) {
+        return `当前工作区思考强度已经是 ${preset}`;
+    }
+    await updateWorkspaceRuntime(target, deps, { reasoningEffort: preset });
+    return `已将当前工作区思考强度切换为 ${preset}`;
+}
+export async function executeRuntimeWorkspaceCommand(options) {
+    const parsed = parseRuntimeCommand(options.commandText);
+    if (!parsed) {
+        return { handled: false, reply: null };
+    }
+    const target = resolveRuntimeWorkspaceTarget(options.chatJid, options.deps);
+    if (!target) {
+        return { handled: true, reply: '未找到当前工作区' };
+    }
+    switch (parsed.name) {
+        case 'help':
+            return {
+                handled: true,
+                reply: buildHelpReply(options.entrypoint, target),
+            };
+        case 'model':
+            if (!parsed.argsText) {
+                return {
+                    handled: true,
+                    reply: `用法: /model <preset>\n可用值：${getModelPresets(normalizeAgentType(target.effectiveGroup.agentType)).join(', ')}`,
+                };
+            }
+            return {
+                handled: true,
+                reply: await handleModelCommand(target, options.deps, parsed.argsText),
+            };
+        case 'effort':
+            if (!parsed.argsText) {
+                return {
+                    handled: true,
+                    reply: `用法: /effort <${getReasoningEffortPresets().join('|')}>`,
+                };
+            }
+            return {
+                handled: true,
+                reply: await handleEffortCommand(target, options.deps, parsed.argsText),
+            };
+        default:
+            return { handled: false, reply: null };
+    }
+}

package/dist/runtime-command-registry.js

@@ -0,0 +1 @@
+export { findRuntimeCommand, formatCommandHelp, getAvailableCommands, getModelPresets, getReasoningEffortPresets, isCommandAvailable, normalizeModelPreset, normalizeReasoningEffortPreset, parseRuntimeCommand, RUNTIME_COMMANDS, supportsReasoningEffort, } from '../shared/dist/runtime-command-registry.js';