@jsonstudio/llms 0.6.1892 → 0.6.2172

package/dist/servertool/handlers/stop-message-stage-policy/observation.js

@@ -0,0 +1,179 @@
+import { createHash } from 'node:crypto';
+import { extractMessageText, normalizeText, normalizeWhitespace } from './text-utils.js';
+function stableStringifyForObservation(value) {
+    if (value === null)
+        return 'null';
+    const type = typeof value;
+    if (type === 'string')
+        return JSON.stringify(value);
+    if (type === 'number')
+        return Number.isFinite(value) ? String(value) : 'null';
+    if (type === 'boolean')
+        return value ? 'true' : 'false';
+    if (type === 'undefined' || type === 'function' || type === 'symbol')
+        return 'null';
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableStringifyForObservation(item)).join(',')}]`;
+    }
+    if (value && typeof value === 'object') {
+        const record = value;
+        const keys = Object.keys(record).sort();
+        const chunks = [];
+        for (const key of keys) {
+            const child = record[key];
+            if (typeof child === 'undefined') {
+                continue;
+            }
+            chunks.push(`${JSON.stringify(key)}:${stableStringifyForObservation(child)}`);
+        }
+        return `{${chunks.join(',')}}`;
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return 'null';
+    }
+}
+function normalizeToolArgumentsForObservation(value) {
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!trimmed) {
+            return '{}';
+        }
+        if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+            try {
+                return stableStringifyForObservation(JSON.parse(trimmed));
+            }
+            catch {
+                return normalizeWhitespace(trimmed);
+            }
+        }
+        return normalizeWhitespace(trimmed);
+    }
+    if (typeof value === 'undefined') {
+        return '{}';
+    }
+    return stableStringifyForObservation(value);
+}
+function extractCommandSignaturesFromText(text) {
+    const signatures = [];
+    const bashRegex = /(?:^|\n)\s*Bash\(([^)\n]{1,1200})\)/g;
+    let bashMatch;
+    while ((bashMatch = bashRegex.exec(text)) !== null) {
+        const command = normalizeWhitespace((bashMatch[1] || '').trim());
+        if (!command)
+            continue;
+        signatures.push(`text.bash(${command})`);
+    }
+    const shellCommandRegex = /"name"\s*:\s*"shell_command"[\s\S]{0,800}?"command"\s*:\s*"([^"\\]*(?:\\.[^"\\]*)*)"/g;
+    let shellCommandMatch;
+    while ((shellCommandMatch = shellCommandRegex.exec(text)) !== null) {
+        const raw = shellCommandMatch[1] || '';
+        const command = normalizeWhitespace(raw.replace(/\\"/g, '"').replace(/\\n/g, ' ').trim());
+        if (!command)
+            continue;
+        signatures.push(`text.shell_command(${command})`);
+    }
+    const xmlCommandRegex = /<parameter\s+name="command">([\s\S]{1,1200}?)<\/parameter>/g;
+    let xmlCommandMatch;
+    while ((xmlCommandMatch = xmlCommandRegex.exec(text)) !== null) {
+        const command = normalizeWhitespace((xmlCommandMatch[1] || '').trim());
+        if (!command)
+            continue;
+        signatures.push(`text.param_command(${command})`);
+    }
+    return signatures;
+}
+function extractToolCallSignatureText(record) {
+    const signatures = [];
+    const appendSignature = (nameValue, argsValue) => {
+        const name = normalizeText(nameValue).toLowerCase();
+        if (!name) {
+            return;
+        }
+        const args = normalizeToolArgumentsForObservation(argsValue);
+        signatures.push(`${name}(${args})`);
+    };
+    const scan = (node) => {
+        if (!node) {
+            return;
+        }
+        if (Array.isArray(node)) {
+            for (const item of node) {
+                scan(item);
+            }
+            return;
+        }
+        if (typeof node !== 'object') {
+            return;
+        }
+        const current = node;
+        if (current.function && typeof current.function === 'object' && !Array.isArray(current.function)) {
+            const fn = current.function;
+            appendSignature(fn.name, fn.arguments);
+        }
+        if (normalizeText(current.type).toLowerCase() === 'function_call') {
+            appendSignature(current.name, current.arguments);
+        }
+        if (typeof current.name === 'string' && Object.prototype.hasOwnProperty.call(current, 'arguments')) {
+            appendSignature(current.name, current.arguments);
+        }
+        if (current.function_call && typeof current.function_call === 'object' && !Array.isArray(current.function_call)) {
+            const fnCall = current.function_call;
+            appendSignature(fnCall.name, fnCall.arguments);
+        }
+    };
+    scan(record.tool_calls);
+    scan(record.tool_call);
+    scan(record.function_call);
+    scan(record.output);
+    const textPayload = extractMessageText(record.content || record.output || record.input || '');
+    if (textPayload) {
+        signatures.push(...extractCommandSignaturesFromText(textPayload));
+    }
+    return signatures.join('; ');
+}
+function extractToolSignatureForHash(message) {
+    if (!message || typeof message !== 'object' || Array.isArray(message)) {
+        return '';
+    }
+    const record = message;
+    return extractToolCallSignatureText(record);
+}
+function normalizeMessageForHash(message) {
+    if (!message || typeof message !== 'object' || Array.isArray(message)) {
+        return '';
+    }
+    const record = message;
+    const role = normalizeText(record.role).toLowerCase() || 'unknown';
+    const text = extractMessageText(record.content || record.output || record.input || '');
+    const toolSignature = extractToolCallSignatureText(record);
+    const combined = [text, toolSignature].filter((entry) => typeof entry === 'string' && entry.trim()).join(' | ');
+    if (!combined) {
+        return role;
+    }
+    return `${role}:${combined.slice(0, 800)}`;
+}
+export function buildObservationHash(messages) {
+    const tail = messages
+        .slice(-20)
+        .map((message) => normalizeMessageForHash(message))
+        .filter(Boolean)
+        .join('\n');
+    if (!tail) {
+        return 'empty';
+    }
+    return createHash('sha1').update(tail).digest('hex').slice(0, 16);
+}
+export function buildToolSignatureHash(messages) {
+    const signatures = messages
+        .slice(-20)
+        .map((message) => extractToolSignatureForHash(message))
+        .filter(Boolean)
+        .join('\n');
+    if (!signatures) {
+        return undefined;
+    }
+    return createHash('sha1').update(signatures).digest('hex').slice(0, 16);
+}

package/dist/servertool/handlers/stop-message-stage-policy/templates.d.ts

@@ -0,0 +1,4 @@
+import type { StageTemplateBundle } from './types.js';
+export declare function buildStageMessage(template: string, baseText: string): string;
+export declare function resolveStageTemplates(mode: 'auto' | 'on'): StageTemplateBundle;
+export declare function resolveStageMode(modeFromState: unknown): 'auto' | 'on' | 'off';

package/dist/servertool/handlers/stop-message-stage-policy/templates.js

@@ -0,0 +1,96 @@
+import { loadStopMessageStageTemplate } from '../../../router/virtual-router/stop-message-stage-template-files.js';
+import { normalizeStageMode, normalizeText } from './text-utils.js';
+const DEFAULT_STATUS_TEMPLATE = [
+    '请围绕当前目标直接推进，不要陷入任务面板操作：',
+    '1) 优先完成一个可验证动作（改代码 / 补测试 / 运行验证）；',
+    '2) 若确实缺少目标或上下文，再一次性补齐必要信息，不要循环轮询；',
+    '3) 仅在动作完成或出现阻塞时，同步记录；',
+    '4) 若执行受阻，输出结构化阻塞信息（见下方约束）以便系统建单。',
+    '',
+    '{{BASE_STOP_MESSAGE}}'
+].join('\n');
+const DEFAULT_ACTIVE_TEMPLATE = [
+    '检测到当前任务可继续，请直接推进工程动作：',
+    '1) 先做实现/修复/验证，不要把任务管理操作当作主要步骤；',
+    '2) 可以调用工具执行代码与验证，避免空状态播报；',
+    '3) 若阻塞，请明确 blocker 并给出 next_action，必要时按结构化格式输出。',
+    '',
+    '{{BASE_STOP_MESSAGE}}'
+].join('\n');
+const DEFAULT_LOOP_TEMPLATE = [
+    '检测到可能出现重复循环，请先自检并尝试跳出：',
+    '1) 对比最近两轮是否重复同一工具调用+参数（包括文本里的命令参数）；',
+    '2) 若重复，改做新的有效动作（改代码、跑测试、定位错误）；',
+    '3) 执行后再观察状态变化；若仍无变化则停止并报告具体阻塞点。',
+    '',
+    '{{BASE_STOP_MESSAGE}}'
+].join('\n');
+const DEFAULT_NO_TASK_SUMMARY_TEMPLATE = [
+    '当前未发现可推进任务。',
+    '请只输出一次收尾总结；不要继续轮询任务列表。',
+    '若存在阻塞，请输出一个 JSON 对象（不要附加解释文本）：',
+    '{"type":"blocked","summary":"...","blocker":"...","impact":"...","next_action":"...","evidence":["..."]}',
+    '',
+    '{{BASE_STOP_MESSAGE}}'
+].join('\n');
+export function buildStageMessage(template, baseText) {
+    const safeBaseText = baseText.trim();
+    const safeTemplate = typeof template === 'string' ? template.trim() : '';
+    if (safeTemplate.includes('{{BASE_STOP_MESSAGE}}')) {
+        const replaced = safeTemplate.replaceAll('{{BASE_STOP_MESSAGE}}', safeBaseText).replace(/\n{3,}/g, '\n\n').trim();
+        if (replaced) {
+            return replaced;
+        }
+    }
+    if (!safeTemplate) {
+        return safeBaseText;
+    }
+    if (!safeBaseText) {
+        return safeTemplate;
+    }
+    return `${safeTemplate}\n\n原始约束：\n${safeBaseText}`.trim();
+}
+function loadStageTemplate(stage) {
+    const loaded = loadStopMessageStageTemplate(stage);
+    return loaded.text || null;
+}
+export function resolveStageTemplates(mode) {
+    const statusProbeTemplate = loadStageTemplate('status_probe');
+    const activeContinueTemplate = loadStageTemplate('active_continue');
+    const loopSelfCheckTemplate = loadStageTemplate('loop_self_check');
+    const hasUserTemplate = Boolean(statusProbeTemplate || activeContinueTemplate || loopSelfCheckTemplate);
+    const enabled = mode === 'on' || hasUserTemplate;
+    if (!enabled) {
+        return {
+            enabled: false,
+            statusProbeTemplate: '',
+            activeContinueTemplate: '',
+            loopSelfCheckTemplate: '',
+            noTaskSummaryTemplate: DEFAULT_NO_TASK_SUMMARY_TEMPLATE
+        };
+    }
+    return {
+        enabled: true,
+        statusProbeTemplate: statusProbeTemplate || DEFAULT_STATUS_TEMPLATE,
+        activeContinueTemplate: activeContinueTemplate || DEFAULT_ACTIVE_TEMPLATE,
+        loopSelfCheckTemplate: loopSelfCheckTemplate || DEFAULT_LOOP_TEMPLATE,
+        noTaskSummaryTemplate: DEFAULT_NO_TASK_SUMMARY_TEMPLATE
+    };
+}
+export function resolveStageMode(modeFromState) {
+    const stateMode = normalizeStageMode(modeFromState);
+    if (stateMode) {
+        return stateMode;
+    }
+    const raw = normalizeText(process.env.ROUTECODEX_STOPMESSAGE_STAGE_MODE).toLowerCase();
+    if (raw === '1' || raw === 'true' || raw === 'on') {
+        return 'on';
+    }
+    if (raw === '0' || raw === 'false' || raw === 'off') {
+        return 'off';
+    }
+    if (raw === 'auto') {
+        return 'auto';
+    }
+    return 'auto';
+}

package/dist/servertool/handlers/stop-message-stage-policy/text-utils.d.ts

@@ -0,0 +1,9 @@
+import type { StopMessageBdWorkState, StopMessageStageName } from './types.js';
+export declare function normalizeWhitespace(text: string): string;
+export declare function normalizeText(value: unknown): string;
+export declare function extractMessageText(value: unknown): string;
+export declare function normalizeMessageForHeuristics(message: unknown): string;
+export declare function normalizeStageName(value: unknown): StopMessageStageName | undefined;
+export declare function normalizeBdWorkState(value: unknown): StopMessageBdWorkState | undefined;
+export declare function normalizeStageMode(value: unknown): 'on' | 'off' | 'auto' | undefined;
+export declare function toSafeInt(value: unknown, fallback: number): number;

package/dist/servertool/handlers/stop-message-stage-policy/text-utils.js

@@ -0,0 +1,89 @@
+export function normalizeWhitespace(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+export function normalizeText(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+export function extractMessageText(value) {
+    if (typeof value === 'string') {
+        return normalizeWhitespace(value);
+    }
+    if (Array.isArray(value)) {
+        const chunks = [];
+        for (const entry of value) {
+            const text = extractMessageText(entry);
+            if (text) {
+                chunks.push(text);
+            }
+        }
+        return normalizeWhitespace(chunks.join('\n'));
+    }
+    if (!value || typeof value !== 'object') {
+        return '';
+    }
+    const record = value;
+    const candidates = [
+        record.text,
+        record.content,
+        record.output_text,
+        record.input_text,
+        record.arguments,
+        record.name,
+        record.result,
+        record.stdout,
+        record.stderr
+    ];
+    const chunks = [];
+    for (const candidate of candidates) {
+        const text = extractMessageText(candidate);
+        if (text) {
+            chunks.push(text);
+        }
+    }
+    return normalizeWhitespace(chunks.join('\n'));
+}
+export function normalizeMessageForHeuristics(message) {
+    if (!message || typeof message !== 'object' || Array.isArray(message)) {
+        return '';
+    }
+    const record = message;
+    const role = normalizeText(record.role).toLowerCase();
+    const text = extractMessageText(record.content || record.output || record.input || '');
+    return `${role}:${text}`.trim();
+}
+export function normalizeStageName(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'status_probe' || normalized === 'active_continue' || normalized === 'loop_self_check') {
+        return normalized;
+    }
+    return undefined;
+}
+export function normalizeBdWorkState(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'active' || normalized === 'idle' || normalized === 'unknown') {
+        return normalized;
+    }
+    return undefined;
+}
+export function normalizeStageMode(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'on' || normalized === 'off' || normalized === 'auto') {
+        return normalized;
+    }
+    return undefined;
+}
+export function toSafeInt(value, fallback) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return fallback;
+    }
+    return Math.max(0, Math.floor(value));
+}

package/dist/servertool/handlers/stop-message-stage-policy/types.d.ts

@@ -0,0 +1,59 @@
+export type StopMessageStageName = 'status_probe' | 'active_continue' | 'loop_self_check';
+export type StopMessageBdWorkState = 'active' | 'idle' | 'unknown';
+export type StopMessageBdMode = 'auto' | 'runtime' | 'heuristic';
+export type StopMessageBdTaskSource = 'in_progress' | 'ready' | 'open';
+export interface StopMessageStageStateSnapshot {
+    stopMessageStage?: string;
+    stopMessageStageMode?: 'on' | 'off' | 'auto' | string;
+    stopMessageObservationHash?: string;
+    stopMessageObservationStableCount?: number;
+    stopMessageBdWorkState?: string;
+    stopMessageNoTaskSummaryUsed?: boolean;
+}
+export interface StopMessageBdCommandResult {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+    error?: unknown;
+}
+export type StopMessageBdCommandRunner = (args: string[], options: {
+    cwd: string;
+    timeoutMs: number;
+}) => StopMessageBdCommandResult;
+export interface StopMessageStageDecision {
+    action: 'followup' | 'stop';
+    stage?: StopMessageStageName;
+    followupText?: string;
+    observationHash: string;
+    observationStableCount: number;
+    toolSignatureHash?: string;
+    bdWorkState: StopMessageBdWorkState;
+    assignedIssueId?: string;
+    assignedIssueTitle?: string;
+    assignedIssueSource?: StopMessageBdTaskSource;
+    noTaskSummaryUsed?: boolean;
+    stopReason?: 'loop_stable' | 'bd_idle' | 'mode_off' | 'no_task_after_summary';
+}
+export interface StopMessageBdTaskSelection {
+    issueId: string;
+    issueTitle: string;
+    priority: number;
+    source: StopMessageBdTaskSource;
+}
+export interface StopMessageBdTaskProbeResult {
+    status: 'ok' | 'unknown';
+    task?: StopMessageBdTaskSelection;
+}
+export interface StageTemplateBundle {
+    enabled: boolean;
+    statusProbeTemplate: string;
+    activeContinueTemplate: string;
+    loopSelfCheckTemplate: string;
+    noTaskSummaryTemplate: string;
+}
+export interface BdRuntimeCacheEntry {
+    mode: StopMessageBdMode;
+    cwd: string;
+    expiresAt: number;
+    state: StopMessageBdWorkState;
+}

package/dist/servertool/handlers/stop-message-stage-policy/types.js

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

package/dist/servertool/handlers/stop-message-stage-policy.d.ts

@@ -1,43 +1,3 @@
-export type StopMessageStageName = 'status_probe' | 'active_continue' | 'loop_self_check';
-export type StopMessageBdWorkState = 'active' | 'idle' | 'unknown';
-export type StopMessageBdMode = 'auto' | 'runtime' | 'heuristic';
-export interface StopMessageStageStateSnapshot {
-    stopMessageStage?: string;
-    stopMessageStageMode?: 'on' | 'off' | 'auto' | string;
-    stopMessageObservationHash?: string;
-    stopMessageObservationStableCount?: number;
-    stopMessageBdWorkState?: string;
-}
-export interface StopMessageBdCommandResult {
-    status: number | null;
-    stdout: string;
-    stderr: string;
-    error?: unknown;
-}
-export type StopMessageBdCommandRunner = (args: string[], options: {
-    cwd: string;
-    timeoutMs: number;
-}) => StopMessageBdCommandResult;
-export interface StopMessageStageDecision {
-    action: 'followup' | 'stop';
-    stage?: StopMessageStageName;
-    followupText?: string;
-    observationHash: string;
-    observationStableCount: number;
-    toolSignatureHash?: string;
-    bdWorkState: StopMessageBdWorkState;
-    stopReason?: 'loop_stable' | 'bd_idle' | 'mode_off';
-}
-export declare function resolveStopMessageStageDecision(args: {
-    baseText: string;
-    state: StopMessageStageStateSnapshot;
-    capturedMessages: unknown[];
-    bdCommandRunner?: StopMessageBdCommandRunner;
-    nowMs?: number;
-}): StopMessageStageDecision;
-export declare function resolveBdWorkStateFromRuntime(options?: {
-    bdCommandRunner?: StopMessageBdCommandRunner;
-    nowMs?: number;
-    cwd?: string;
-}): StopMessageBdWorkState;
-export declare function resetStopMessageBdRuntimeCacheForTests(): void;
+export type { StopMessageBdCommandResult, StopMessageBdCommandRunner, StopMessageBdMode, StopMessageBdTaskSelection, StopMessageBdTaskSource, StopMessageBdWorkState, StopMessageStageDecision, StopMessageStageName, StopMessageStageStateSnapshot } from './stop-message-stage-policy/types.js';
+export { resolveStopMessageStageDecision } from './stop-message-stage-policy/decision.js';
+export { resetStopMessageBdRuntimeCacheForTests, resolveBdTaskSelectionFromRuntime, resolveBdWorkStateFromRuntime } from './stop-message-stage-policy/bd-runtime.js';