@jsonstudio/llms 0.6.1892 → 0.6.2172

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

@@ -0,0 +1,18 @@
+import type { StopMessageBdCommandRunner, StopMessageBdTaskProbeResult, StopMessageBdWorkState } from './types.js';
+export declare function resolveBdTaskSelectionFromRuntime(options?: {
+    bdCommandRunner?: StopMessageBdCommandRunner;
+    nowMs?: number;
+    cwd?: string;
+    limit?: number;
+}): StopMessageBdTaskProbeResult;
+export declare function resolveBdWorkStateFromRuntime(options?: {
+    bdCommandRunner?: StopMessageBdCommandRunner;
+    nowMs?: number;
+    cwd?: string;
+}): StopMessageBdWorkState;
+export declare function detectBdWorkState(messages: unknown[], options?: {
+    bdCommandRunner?: StopMessageBdCommandRunner;
+    nowMs?: number;
+    cwd?: string;
+}): StopMessageBdWorkState;
+export declare function resetStopMessageBdRuntimeCacheForTests(): void;

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

@@ -0,0 +1,398 @@
+import * as childProcess from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { normalizeMessageForHeuristics, normalizeText } from './text-utils.js';
+let bdRuntimeCache = null;
+const DEFAULT_BD_TIMEOUT_MS = 1200;
+const DEFAULT_BD_CACHE_TTL_MS = 1500;
+export function resolveBdTaskSelectionFromRuntime(options) {
+    const commandRunner = options?.bdCommandRunner ?? runBdCommand;
+    const timeoutMs = resolveBdTimeoutMs();
+    const cwd = resolveBdWorkingDirectory(options?.cwd);
+    const limit = typeof options?.limit === 'number' && Number.isFinite(options.limit) && options.limit > 0
+        ? Math.max(1, Math.floor(options.limit))
+        : 20;
+    const inProgress = runBdIssueQuery(commandRunner, ['--no-db', 'list', '--status', 'in_progress', '--json', '--limit', String(limit)], { cwd, timeoutMs, source: 'in_progress' });
+    if (inProgress.status === 'unknown')
+        return { status: 'unknown' };
+    if (inProgress.issues.length > 0)
+        return { status: 'ok', task: inProgress.issues[0] };
+    const ready = runBdIssueQuery(commandRunner, ['--no-db', 'ready', '--json', '--limit', String(limit)], {
+        cwd,
+        timeoutMs,
+        source: 'ready'
+    });
+    if (ready.status === 'unknown')
+        return { status: 'unknown' };
+    if (ready.issues.length > 0)
+        return { status: 'ok', task: ready.issues[0] };
+    const open = runBdIssueQuery(commandRunner, ['--no-db', 'list', '--status', 'open', '--json', '--limit', String(limit)], {
+        cwd,
+        timeoutMs,
+        source: 'open'
+    });
+    if (open.status === 'unknown')
+        return { status: 'unknown' };
+    if (open.issues.length > 0)
+        return { status: 'ok', task: open.issues[0] };
+    return { status: 'ok' };
+}
+export function resolveBdWorkStateFromRuntime(options) {
+    const mode = resolveBdMode();
+    const nowMs = typeof options?.nowMs === 'number' && Number.isFinite(options.nowMs) ? options.nowMs : Date.now();
+    const cwd = resolveBdWorkingDirectory(options?.cwd);
+    const ttlMs = resolveBdCacheTtlMs();
+    if (ttlMs > 0 &&
+        bdRuntimeCache &&
+        bdRuntimeCache.mode === mode &&
+        bdRuntimeCache.cwd === cwd &&
+        bdRuntimeCache.expiresAt > nowMs) {
+        return bdRuntimeCache.state;
+    }
+    const commandRunner = options?.bdCommandRunner ?? runBdCommand;
+    const timeoutMs = resolveBdTimeoutMs();
+    const inProgress = runBdQuery(commandRunner, ['--no-db', 'list', '--status', 'in_progress', '--json', '--limit', '1'], {
+        cwd,
+        timeoutMs
+    });
+    if (inProgress === 'active') {
+        return writeBdRuntimeCacheAndReturn(mode, cwd, nowMs, ttlMs, 'active');
+    }
+    if (inProgress === 'unknown') {
+        return writeBdRuntimeCacheAndReturn(mode, cwd, nowMs, ttlMs, 'unknown');
+    }
+    const ready = runBdQuery(commandRunner, ['--no-db', 'ready', '--json', '--limit', '1'], {
+        cwd,
+        timeoutMs
+    });
+    if (ready === 'active') {
+        return writeBdRuntimeCacheAndReturn(mode, cwd, nowMs, ttlMs, 'active');
+    }
+    if (ready === 'unknown') {
+        return writeBdRuntimeCacheAndReturn(mode, cwd, nowMs, ttlMs, 'unknown');
+    }
+    const open = runBdQuery(commandRunner, ['--no-db', 'list', '--status', 'open', '--json', '--limit', '1'], {
+        cwd,
+        timeoutMs
+    });
+    if (open === 'active') {
+        return writeBdRuntimeCacheAndReturn(mode, cwd, nowMs, ttlMs, 'active');
+    }
+    if (open === 'unknown') {
+        return writeBdRuntimeCacheAndReturn(mode, cwd, nowMs, ttlMs, 'unknown');
+    }
+    const blocked = runBdQuery(commandRunner, ['--no-db', 'list', '--status', 'blocked', '--json', '--limit', '1'], {
+        cwd,
+        timeoutMs
+    });
+    if (blocked === 'active') {
+        return writeBdRuntimeCacheAndReturn(mode, cwd, nowMs, ttlMs, 'active');
+    }
+    if (blocked === 'unknown') {
+        return writeBdRuntimeCacheAndReturn(mode, cwd, nowMs, ttlMs, 'unknown');
+    }
+    return writeBdRuntimeCacheAndReturn(mode, cwd, nowMs, ttlMs, 'idle');
+}
+export function detectBdWorkState(messages, options) {
+    const mode = resolveBdMode();
+    if (mode !== 'heuristic') {
+        const runtimeState = resolveBdWorkStateFromRuntime({
+            bdCommandRunner: options?.bdCommandRunner,
+            nowMs: options?.nowMs,
+            cwd: options?.cwd
+        });
+        if (runtimeState === 'active' || runtimeState === 'idle') {
+            return runtimeState;
+        }
+        if (mode === 'runtime') {
+            return 'unknown';
+        }
+    }
+    return detectBdWorkStateFromHeuristics(messages);
+}
+export function resetStopMessageBdRuntimeCacheForTests() {
+    bdRuntimeCache = null;
+}
+function detectBdWorkStateFromHeuristics(messages) {
+    const normalizedTail = messages
+        .slice(-30)
+        .map((message) => normalizeMessageForHeuristics(message))
+        .filter(Boolean)
+        .join('\n')
+        .toLowerCase();
+    if (!normalizedTail.includes('bd')) {
+        return 'unknown';
+    }
+    const idlePatterns = [
+        /\bno\s+(ready|open|in_progress)\b/i,
+        /\b0\s+(ready|open|in_progress)\b/i,
+        /\bnothing\s+(to\s+do|ready|in\s+progress)\b/i,
+        /\ball\s+(tasks?|issues?)\s+(done|closed)\b/i,
+        /没有可(做|推进)任务/i,
+        /无\s*(ready|open|in_progress)\s*任务/i
+    ];
+    if (idlePatterns.some((pattern) => pattern.test(normalizedTail))) {
+        return 'idle';
+    }
+    const activePatterns = [/\bin_progress\b/i, /\bready\b/i, /\bblocked\b/i, /\bopen\b/i, /\bepic status\b/i, /\bshow\s+[a-z0-9._-]+\b/i];
+    if (activePatterns.some((pattern) => pattern.test(normalizedTail))) {
+        return 'active';
+    }
+    return 'unknown';
+}
+function writeBdRuntimeCacheAndReturn(mode, cwd, nowMs, ttlMs, state) {
+    if (ttlMs > 0) {
+        bdRuntimeCache = {
+            mode,
+            cwd,
+            expiresAt: nowMs + ttlMs,
+            state
+        };
+    }
+    return state;
+}
+function resolveBdMode() {
+    const modeRaw = normalizeText(process.env.ROUTECODEX_STOPMESSAGE_BD_MODE).toLowerCase();
+    if (modeRaw === 'runtime' || modeRaw === 'real') {
+        return 'runtime';
+    }
+    if (modeRaw === 'heuristic' || modeRaw === 'text') {
+        return 'heuristic';
+    }
+    const legacyRuntimeRaw = normalizeText(process.env.ROUTECODEX_STOPMESSAGE_BD_RUNTIME).toLowerCase();
+    if (legacyRuntimeRaw === '1' || legacyRuntimeRaw === 'true' || legacyRuntimeRaw === 'on') {
+        return 'runtime';
+    }
+    if (legacyRuntimeRaw === '0' || legacyRuntimeRaw === 'false' || legacyRuntimeRaw === 'off') {
+        return 'heuristic';
+    }
+    return 'auto';
+}
+function resolveBdCacheTtlMs() {
+    const parsed = parseNonNegativeInteger(process.env.ROUTECODEX_STOPMESSAGE_BD_CACHE_TTL_MS);
+    if (typeof parsed === 'number') {
+        return parsed;
+    }
+    return DEFAULT_BD_CACHE_TTL_MS;
+}
+function resolveBdTimeoutMs() {
+    const parsed = parsePositiveInteger(process.env.ROUTECODEX_STOPMESSAGE_BD_TIMEOUT_MS);
+    if (typeof parsed === 'number') {
+        return parsed;
+    }
+    return DEFAULT_BD_TIMEOUT_MS;
+}
+function parseNonNegativeInteger(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const parsed = Number.parseInt(value.trim(), 10);
+    if (!Number.isFinite(parsed) || parsed < 0) {
+        return undefined;
+    }
+    return parsed;
+}
+function parsePositiveInteger(value) {
+    const parsed = parseNonNegativeInteger(value);
+    if (typeof parsed !== 'number' || parsed <= 0) {
+        return undefined;
+    }
+    return parsed;
+}
+function resolveBdWorkingDirectory(cwdOverride) {
+    const fromOverride = normalizeText(cwdOverride);
+    if (fromOverride) {
+        return path.resolve(fromOverride);
+    }
+    const fromEnv = normalizeText(process.env.ROUTECODEX_STOPMESSAGE_BD_WORKDIR);
+    if (fromEnv) {
+        return path.resolve(fromEnv);
+    }
+    const current = process.cwd();
+    return findBdProjectRoot(current) || current;
+}
+function findBdProjectRoot(startDirectory) {
+    let current = path.resolve(startDirectory);
+    while (true) {
+        const beadsDir = path.join(current, '.beads');
+        const issuesJsonlPath = path.join(beadsDir, 'issues.jsonl');
+        if (fs.existsSync(issuesJsonlPath)) {
+            return current;
+        }
+        if (fs.existsSync(beadsDir)) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return null;
+        }
+        current = parent;
+    }
+}
+function runBdCommand(args, options) {
+    try {
+        const result = childProcess.spawnSync('bd', args, {
+            cwd: options.cwd,
+            encoding: 'utf8',
+            timeout: options.timeoutMs,
+            maxBuffer: 1024 * 1024
+        });
+        return {
+            status: result.status,
+            stdout: typeof result.stdout === 'string' ? result.stdout : String(result.stdout ?? ''),
+            stderr: typeof result.stderr === 'string' ? result.stderr : String(result.stderr ?? ''),
+            error: result.error
+        };
+    }
+    catch (error) {
+        return {
+            status: null,
+            stdout: '',
+            stderr: '',
+            error
+        };
+    }
+}
+function runBdQuery(commandRunner, args, options) {
+    const result = commandRunner(args, options);
+    if (result.error || result.status !== 0) {
+        return 'unknown';
+    }
+    const list = parseJsonArrayOutput(result.stdout);
+    if (!list) {
+        return 'unknown';
+    }
+    return list.length > 0 ? 'active' : 'idle';
+}
+function runBdIssueQuery(commandRunner, args, options) {
+    const result = commandRunner(args, { cwd: options.cwd, timeoutMs: options.timeoutMs });
+    if (result.error || result.status !== 0) {
+        return { status: 'unknown', issues: [] };
+    }
+    const list = parseJsonArrayOutput(result.stdout);
+    if (!list) {
+        return { status: 'unknown', issues: [] };
+    }
+    if (list.length === 0) {
+        return { status: 'ok', issues: [] };
+    }
+    const issues = list
+        .map((item) => normalizeIssueSelection(item, options.source))
+        .filter((item) => Boolean(item))
+        .sort(compareIssueSelection);
+    if (issues.length === 0) {
+        return { status: 'unknown', issues: [] };
+    }
+    return { status: 'ok', issues };
+}
+function parseJsonArrayOutput(stdout) {
+    const trimmed = typeof stdout === 'string' ? stdout.trim() : '';
+    if (!trimmed) {
+        return [];
+    }
+    const parsedDirect = parseJsonArray(trimmed);
+    if (parsedDirect) {
+        return parsedDirect;
+    }
+    const firstBracket = trimmed.indexOf('[');
+    const lastBracket = trimmed.lastIndexOf(']');
+    if (firstBracket >= 0 && lastBracket > firstBracket) {
+        const arraySlice = trimmed.slice(firstBracket, lastBracket + 1).trim();
+        const parsedSlice = parseJsonArray(arraySlice);
+        if (parsedSlice) {
+            return parsedSlice;
+        }
+    }
+    return null;
+}
+function parseJsonArray(raw) {
+    try {
+        const value = JSON.parse(raw);
+        if (Array.isArray(value)) {
+            return value;
+        }
+        if (value && typeof value === 'object') {
+            const record = value;
+            if (Array.isArray(record.items)) {
+                return record.items;
+            }
+            if (Array.isArray(record.issues)) {
+                return record.issues;
+            }
+            if (Array.isArray(record.data)) {
+                return record.data;
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeIssueSelection(item, source) {
+    if (!item || typeof item !== 'object' || Array.isArray(item)) {
+        return null;
+    }
+    const record = item;
+    const issueId = normalizeText(record.id);
+    if (!issueId) {
+        return null;
+    }
+    const issueTitle = normalizeText(record.title) ||
+        normalizeText(record.summary) ||
+        normalizeText(record.name) ||
+        `Issue ${issueId}`;
+    const priority = parseIssuePriority(record.priority);
+    return {
+        issueId,
+        issueTitle: issueTitle.slice(0, 240),
+        priority,
+        source
+    };
+}
+function parseIssuePriority(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return Math.max(0, Math.floor(value));
+    }
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        const pMatch = normalized.match(/^p?(\d+)$/);
+        if (pMatch) {
+            const parsed = Number.parseInt(pMatch[1], 10);
+            if (Number.isFinite(parsed)) {
+                return Math.max(0, parsed);
+            }
+        }
+    }
+    return 99;
+}
+function compareIssueSelection(a, b) {
+    if (a.priority !== b.priority) {
+        return a.priority - b.priority;
+    }
+    const idCompare = compareIssueId(a.issueId, b.issueId);
+    if (idCompare !== 0) {
+        return idCompare;
+    }
+    return a.issueTitle.localeCompare(b.issueTitle);
+}
+function compareIssueId(left, right) {
+    const leftParts = left.match(/\d+|\D+/g) || [left];
+    const rightParts = right.match(/\d+|\D+/g) || [right];
+    const maxLen = Math.max(leftParts.length, rightParts.length);
+    for (let idx = 0; idx < maxLen; idx += 1) {
+        const l = leftParts[idx] || '';
+        const r = rightParts[idx] || '';
+        const lNum = /^\d+$/.test(l) ? Number.parseInt(l, 10) : NaN;
+        const rNum = /^\d+$/.test(r) ? Number.parseInt(r, 10) : NaN;
+        if (Number.isFinite(lNum) && Number.isFinite(rNum)) {
+            if (lNum !== rNum)
+                return lNum - rNum;
+            continue;
+        }
+        const compare = l.localeCompare(r);
+        if (compare !== 0)
+            return compare;
+    }
+    return 0;
+}

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

@@ -0,0 +1,9 @@
+import type { StopMessageBdCommandRunner, StopMessageStageDecision, StopMessageStageStateSnapshot } from './types.js';
+export declare function resolveStopMessageStageDecision(args: {
+    baseText: string;
+    state: StopMessageStageStateSnapshot;
+    capturedMessages: unknown[];
+    bdCommandRunner?: StopMessageBdCommandRunner;
+    bdWorkingDirectory?: string;
+    nowMs?: number;
+}): StopMessageStageDecision;

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

@@ -0,0 +1,127 @@
+import { detectBdWorkState, resolveBdTaskSelectionFromRuntime } from './bd-runtime.js';
+import { buildObservationHash, buildToolSignatureHash } from './observation.js';
+import { buildStageMessage, resolveStageMode, resolveStageTemplates } from './templates.js';
+import { normalizeBdWorkState, normalizeStageName, normalizeText, toSafeInt } from './text-utils.js';
+function buildAssignedTaskBaseText(baseText, assignedTask) {
+    const assignmentLine = `系统已分配任务：${assignedTask.issueId} - ${assignedTask.issueTitle}（来源：${assignedTask.source}）`;
+    const behaviorLine = '请直接执行该任务，优先推进实现、修复与验证。';
+    const suffix = normalizeText(baseText);
+    if (!suffix) {
+        return `${assignmentLine}\n${behaviorLine}`.trim();
+    }
+    return `${assignmentLine}\n${behaviorLine}\n\n${suffix}`.trim();
+}
+export function resolveStopMessageStageDecision(args) {
+    const mode = resolveStageMode(args.state.stopMessageStageMode);
+    const observationHash = buildObservationHash(args.capturedMessages);
+    const toolSignatureHash = buildToolSignatureHash(args.capturedMessages);
+    if (mode === 'off') {
+        return {
+            action: 'stop',
+            observationHash,
+            observationStableCount: 0,
+            bdWorkState: 'unknown',
+            stopReason: 'mode_off',
+            ...(toolSignatureHash ? { toolSignatureHash } : {})
+        };
+    }
+    const templates = resolveStageTemplates(mode);
+    if (!templates.enabled) {
+        return {
+            action: 'followup',
+            followupText: args.baseText,
+            observationHash,
+            observationStableCount: 0,
+            bdWorkState: 'unknown',
+            ...(toolSignatureHash ? { toolSignatureHash } : {})
+        };
+    }
+    const previousHash = normalizeText(args.state.stopMessageObservationHash);
+    const previousStableCount = toSafeInt(args.state.stopMessageObservationStableCount, 0);
+    const stableCount = previousHash && previousHash === observationHash ? previousStableCount + 1 : 0;
+    const taskProbe = resolveBdTaskSelectionFromRuntime({
+        bdCommandRunner: args.bdCommandRunner,
+        cwd: args.bdWorkingDirectory,
+        nowMs: args.nowMs
+    });
+    const assignedTask = taskProbe.status === 'ok' ? taskProbe.task : undefined;
+    const bdWorkState = detectBdWorkState(args.capturedMessages, {
+        bdCommandRunner: args.bdCommandRunner,
+        cwd: args.bdWorkingDirectory,
+        nowMs: args.nowMs
+    });
+    if (taskProbe.status === 'ok' && !assignedTask) {
+        if (Boolean(args.state.stopMessageNoTaskSummaryUsed)) {
+            return {
+                action: 'stop',
+                observationHash,
+                observationStableCount: stableCount,
+                bdWorkState,
+                noTaskSummaryUsed: true,
+                stopReason: 'no_task_after_summary',
+                ...(toolSignatureHash ? { toolSignatureHash } : {})
+            };
+        }
+        return {
+            action: 'followup',
+            stage: 'status_probe',
+            followupText: buildStageMessage(templates.noTaskSummaryTemplate, args.baseText),
+            observationHash,
+            observationStableCount: stableCount,
+            bdWorkState,
+            noTaskSummaryUsed: true,
+            ...(toolSignatureHash ? { toolSignatureHash } : {})
+        };
+    }
+    if (mode !== 'on') {
+        const previousStage = normalizeStageName(args.state.stopMessageStage);
+        const previousBdWorkState = normalizeBdWorkState(args.state.stopMessageBdWorkState);
+        const idleConfirmed = bdWorkState === 'idle' && previousBdWorkState === 'idle' && previousStage === 'status_probe';
+        if (bdWorkState === 'idle') {
+            if (idleConfirmed) {
+                return {
+                    action: 'stop',
+                    observationHash,
+                    observationStableCount: stableCount,
+                    bdWorkState,
+                    stopReason: 'bd_idle',
+                    ...(toolSignatureHash ? { toolSignatureHash } : {})
+                };
+            }
+        }
+        if (stableCount >= 2) {
+            return {
+                action: 'stop',
+                observationHash,
+                observationStableCount: stableCount,
+                bdWorkState,
+                stopReason: 'loop_stable',
+                ...(toolSignatureHash ? { toolSignatureHash } : {})
+            };
+        }
+    }
+    const stage = stableCount > 0 ? 'loop_self_check' : bdWorkState === 'active' ? 'active_continue' : 'status_probe';
+    const stageTemplate = stage === 'status_probe'
+        ? templates.statusProbeTemplate
+        : stage === 'active_continue'
+            ? templates.activeContinueTemplate
+            : templates.loopSelfCheckTemplate;
+    const followupText = buildStageMessage(stageTemplate, assignedTask ? buildAssignedTaskBaseText(args.baseText, assignedTask) : args.baseText);
+    return {
+        action: 'followup',
+        stage,
+        followupText,
+        observationHash,
+        observationStableCount: stableCount,
+        bdWorkState,
+        ...(assignedTask
+            ? {
+                assignedIssueId: assignedTask.issueId,
+                assignedIssueTitle: assignedTask.issueTitle,
+                assignedIssueSource: assignedTask.source
+            }
+            : {}),
+        noTaskSummaryUsed: false,
+        ...(toolSignatureHash ? { toolSignatureHash } : {})
+    };
+}

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

@@ -0,0 +1,2 @@
+export declare function buildObservationHash(messages: unknown[]): string;
+export declare function buildToolSignatureHash(messages: unknown[]): string | undefined;