@orion-agents/orion-code 0.3.4 → 0.3.9

package/dist/runtime/subagents/research-renderer.js

@@ -126,7 +126,9 @@ function renderTerminal(view) {
 }
 function renderPrint(view) {
     // Stable schema text (not raw concatenated claim text).
-    const claims = view.claims.map(c => `  - ${c.id}: ${c.verification} (${c.bindingStatus})`).join('\n');
+    const claims = view.claims
+        .map(c => `  - ${c.id}: ${c.verification} (${c.bindingStatus})`)
+        .join('\n');
     return [
         `# Research: ${view.objective}`,
         `Status: ${view.stage} | Audit: ${view.auditStatus}`,
@@ -139,7 +141,12 @@ function renderPrint(view) {
 }
 function toLifecycleEvents(view, resolution) {
     const events = [
-        { type: 'research_started', packetId: view.packetId, objective: view.objective, mode: view.mode },
+        {
+            type: 'research_started',
+            packetId: view.packetId,
+            objective: view.objective,
+            mode: view.mode,
+        },
     ];
     for (const s of view.sources) {
         events.push({

package/dist/runtime/subagents/result-parser.js

@@ -46,7 +46,9 @@ function parseFindings(raw) {
             severity: parseSeverity(obj.severity),
             evidence: str(obj.evidence, 1500),
             file: obj.file != null ? str(obj.file, 500) : undefined,
-            line: typeof obj.line === 'number' && Number.isFinite(obj.line) ? Math.max(0, Math.floor(obj.line)) : undefined,
+            line: typeof obj.line === 'number' && Number.isFinite(obj.line)
+                ? Math.max(0, Math.floor(obj.line))
+                : undefined,
         });
         if (out.length >= MAX_FINDINGS)
             break;
@@ -54,7 +56,11 @@ function parseFindings(raw) {
     return out;
 }
 function parseSeverity(value) {
-    if (value === 'critical' || value === 'high' || value === 'medium' || value === 'low' || value === 'info') {
+    if (value === 'critical' ||
+        value === 'high' ||
+        value === 'medium' ||
+        value === 'low' ||
+        value === 'info') {
         return value;
     }
     return undefined;
@@ -163,11 +169,16 @@ function parseSubtaskResult(args) {
 function summarizeFailure(status, content) {
     const tail = truncate(content.trim(), 300);
     switch (status) {
-        case 'timed_out': return `Child timed out. Partial output: ${tail || '(none)'}`;
-        case 'cancelled': return `Child was cancelled. Partial output: ${tail || '(none)'}`;
-        case 'failed': return `Child failed. Output: ${tail || '(none)'}`;
-        case 'rejected': return `Child was rejected by policy before running.`;
-        default: return tail || '(no output)';
+        case 'timed_out':
+            return `Child timed out. Partial output: ${tail || '(none)'}`;
+        case 'cancelled':
+            return `Child was cancelled. Partial output: ${tail || '(none)'}`;
+        case 'failed':
+            return `Child failed. Output: ${tail || '(none)'}`;
+        case 'rejected':
+            return `Child was rejected by policy before running.`;
+        default:
+            return tail || '(no output)';
     }
 }
 //# sourceMappingURL=result-parser.js.map

package/dist/runtime/thread-event-store.d.ts

@@ -1,5 +1,5 @@
 import { type RuntimeEventEnvelopeV1, type RuntimeEventV1 } from './protocol/runtime-protocol-v1';
-import { type ThreadProjectionV1 } from './thread-projection';
+import { type ThreadProjectionDigestVersionV1, type ThreadProjectionV1 } from './thread-projection';
 import type { CompactAuthoritativeSourceV1, CompactCheckpointCommitReceiptV1, CompactCompareAndCommitInputV1, CompactCompareAndCommitResultV1, CompactRuntimeEventV1 } from './compact-transaction';
 export interface AppendRuntimeEventV1<T extends RuntimeEventV1 = RuntimeEventV1> {
     readonly turnId?: string;
@@ -14,7 +14,7 @@ export interface ThreadEventReplayV1 {
     readonly nextCursor: number;
     readonly hasMore: boolean;
 }
-export type ThreadEventReplayReasonV1 = 'direct' | 'capability_receipt_journal' | 'durable_tool_receipt' | 'legacy_materializer' | 'runtime_diagnostics_legacy' | 'subagent_receipt_journal' | 'thread_session_view' | 'turn_commit_journal' | 'ui_gap_recovery' | 'ui_initial_history';
+export type ThreadEventReplayReasonV1 = 'direct' | 'capability_receipt_journal' | 'durable_tool_receipt' | 'legacy_materializer' | 'projection_schema_upgrade' | 'runtime_diagnostics_legacy' | 'subagent_receipt_journal' | 'thread_session_view' | 'turn_commit_journal' | 'ui_gap_recovery' | 'ui_initial_history';
 export interface ThreadEventCommitV1 {
     readonly events: readonly RuntimeEventEnvelopeV1[];
     readonly projection: ThreadProjectionV1;
@@ -44,6 +44,8 @@ export interface ThreadVerifiedPrefixV1 {
     readonly cursor: number;
     readonly eventDigest: string;
     readonly projectionDigest: string;
+    /** Missing on receipts written before projection digests were versioned. */
+    readonly projectionDigestVersion?: ThreadProjectionDigestVersionV1;
 }
 /**
  * Crash-safe derived checkpoint for opening a Thread in a fresh process.
@@ -136,7 +138,7 @@ export declare class ThreadEventStore {
      * exact log identity/projection checkpoint remains current. Internal append
      * carries the proof forward because the hash-chained prefix cannot change.
      */
-    verifyDurablePrefix(cursor: number, eventDigest: string, projectionDigest: string): boolean;
+    verifyDurablePrefix(cursor: number, eventDigest: string, projectionDigest: string, projectionDigestVersion?: ThreadProjectionDigestVersionV1): boolean;
     getCursor(): number;
     /**
      * Read the compact persisted receipt without parsing the potentially large

package/dist/runtime/thread-event-store.js

@@ -71,7 +71,12 @@ class ThreadEventStore {
         }
         const commit = this.withLogLock(() => {
             ensurePrivateDirectory(this.rootDir);
-            const head = this.loadVerifiedHead();
+            let head = this.loadVerifiedHead();
+            if (!(0, thread_projection_1.hasCurrentThreadProjectionShapeV1)(head.projection)) {
+                // An older projection cannot be incrementally advanced because it did
+                // not retain all diagnostic/compact history. Rebuild from facts once.
+                head = this.loadVerifiedHead(true, 'projection_schema_upgrade');
+            }
             if (head.discardedTailBytes > 0)
                 (0, fs_1.truncateSync)(this.logPath, head.safeByteLength);
             let seq = head.projection.cursor;
@@ -216,7 +221,7 @@ class ThreadEventStore {
      * exact log identity/projection checkpoint remains current. Internal append
      * carries the proof forward because the hash-chained prefix cannot change.
      */
-    verifyDurablePrefix(cursor, eventDigest, projectionDigest) {
+    verifyDurablePrefix(cursor, eventDigest, projectionDigest, projectionDigestVersion) {
         if (!Number.isSafeInteger(cursor) ||
             cursor <= 0 ||
             !isSha256(eventDigest) ||
@@ -227,21 +232,31 @@ class ThreadEventStore {
             let head = this.loadVerifiedHead();
             if (cursor > head.projection.cursor)
                 return false;
-            const expected = { cursor, eventDigest, projectionDigest };
+            const expected = { cursor, eventDigest, projectionDigest, projectionDigestVersion };
             if (head.verifiedPrefixes.some(prefix => sameVerifiedPrefix(prefix, expected)))
                 return true;
             head = this.loadVerifiedHead(true, 'verify_durable_prefix');
             const scan = requireVerifiedScan(head);
             const events = scan.events.slice(0, cursor);
+            const resolvedProjectionDigestVersion = (0, thread_projection_1.resolveThreadProjectionDigestVersionV1)((0, thread_projection_1.projectThreadEvents)(this.threadId, events), projectionDigest, projectionDigestVersion);
             if (events.length !== cursor ||
                 (0, canonical_1.digestRuntimeValue)(events) !== eventDigest ||
-                (0, thread_projection_1.projectThreadEvents)(this.threadId, events).digest !== projectionDigest) {
+                resolvedProjectionDigestVersion === undefined) {
                 return false;
             }
+            const verified = {
+                cursor,
+                eventDigest,
+                projectionDigest,
+                projectionDigestVersion: resolvedProjectionDigestVersion,
+            };
             const next = {
                 ...head,
                 generation: head.generation + 1,
-                verifiedPrefixes: [...head.verifiedPrefixes, expected].sort((left, right) => left.cursor - right.cursor),
+                verifiedPrefixes: [
+                    ...head.verifiedPrefixes.filter(prefix => prefix.cursor !== cursor),
+                    verified,
+                ].sort((left, right) => left.cursor - right.cursor),
             };
             this.cachedHead = next;
             this.tryPersistVerifiedHead(next);
@@ -858,7 +873,7 @@ function retainVerifiedPrefixes(prefixes, scan, threadId) {
             return false;
         const events = scan.events.slice(0, prefix.cursor);
         return ((0, canonical_1.digestRuntimeValue)(events) === prefix.eventDigest &&
-            (0, thread_projection_1.projectThreadEvents)(threadId, events).digest === prefix.projectionDigest);
+            (0, thread_projection_1.resolveThreadProjectionDigestVersionV1)((0, thread_projection_1.projectThreadEvents)(threadId, events), prefix.projectionDigest, prefix.projectionDigestVersion) !== undefined);
     });
 }
 function requireVerifiedScan(head) {
@@ -891,12 +906,18 @@ function isStoredVerifiedPrefix(value, headCursor) {
         value.cursor > 0 &&
         value.cursor <= headCursor &&
         isSha256(value.eventDigest) &&
-        isSha256(value.projectionDigest));
+        isSha256(value.projectionDigest) &&
+        (value.projectionDigestVersion === undefined ||
+            value.projectionDigestVersion === 1 ||
+            value.projectionDigestVersion === thread_projection_1.CURRENT_THREAD_PROJECTION_DIGEST_VERSION_V1));
 }
 function sameVerifiedPrefix(left, right) {
     return (left.cursor === right.cursor &&
         left.eventDigest === right.eventDigest &&
-        left.projectionDigest === right.projectionDigest);
+        left.projectionDigest === right.projectionDigest &&
+        (left.projectionDigestVersion === right.projectionDigestVersion ||
+            left.projectionDigestVersion === undefined ||
+            right.projectionDigestVersion === undefined));
 }
 function isStoredLogIdentity(value) {
     return (isRecord(value) &&

package/dist/runtime/thread-projection.d.ts

@@ -2,6 +2,14 @@ import type { RuntimeEventEnvelopeV1, RuntimeEventTypeV1 } from './protocol/runt
 import type { CompactRuntimeEventV1 } from './compact-transaction';
 export type ThreadProjectionStatusV1 = 'new' | 'active' | 'idle';
 export type TurnProjectionStatusV1 = 'active' | 'completed' | 'failed' | 'interrupted';
+/**
+ * Version of the canonical content included in a Thread projection digest.
+ *
+ * Version 1 predates head-only diagnostic and compact lifecycle fields.
+ * Version 2 covers the complete current projection shape.
+ */
+export type ThreadProjectionDigestVersionV1 = 1 | 2;
+export declare const CURRENT_THREAD_PROJECTION_DIGEST_VERSION_V1: ThreadProjectionDigestVersionV1;
 export type ItemProjectionStatusV1 = 'started' | 'completed' | 'failed' | 'interrupted' | 'indeterminate';
 export interface ItemProjectionV1 {
     readonly itemId: string;
@@ -133,5 +141,14 @@ export declare function projectThreadEvents(threadId: string, events: readonly R
 export declare function advanceThreadProjection(projection: ThreadProjectionV1, events: readonly RuntimeEventEnvelopeV1[]): ThreadProjectionV1;
 export declare function applyThreadEvent(state: MutableThreadProjectionV1, event: RuntimeEventEnvelopeV1): void;
 export declare function verifyThreadProjectionDigest(projection: ThreadProjectionV1): boolean;
+/**
+ * Compute one explicitly versioned digest without weakening projection-file
+ * integrity. This is used only for immutable cutover-prefix compatibility.
+ */
+export declare function threadProjectionDigestForVersionV1(projection: ThreadProjectionV1, version: ThreadProjectionDigestVersionV1): string;
+/** Resolve an exact known digest scheme; missing metadata is inferred safely. */
+export declare function resolveThreadProjectionDigestVersionV1(projection: ThreadProjectionV1, digest: string, requestedVersion?: ThreadProjectionDigestVersionV1): ThreadProjectionDigestVersionV1 | undefined;
+/** Older persisted projections must be rebuilt before incremental advance. */
+export declare function hasCurrentThreadProjectionShapeV1(projection: ThreadProjectionV1): boolean;
 export {};
 //# sourceMappingURL=thread-projection.d.ts.map

package/dist/runtime/thread-projection.js

@@ -1,11 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ThreadProjectionInvariantError = void 0;
+exports.ThreadProjectionInvariantError = exports.CURRENT_THREAD_PROJECTION_DIGEST_VERSION_V1 = void 0;
 exports.projectThreadEvents = projectThreadEvents;
 exports.advanceThreadProjection = advanceThreadProjection;
 exports.applyThreadEvent = applyThreadEvent;
 exports.verifyThreadProjectionDigest = verifyThreadProjectionDigest;
+exports.threadProjectionDigestForVersionV1 = threadProjectionDigestForVersionV1;
+exports.resolveThreadProjectionDigestVersionV1 = resolveThreadProjectionDigestVersionV1;
+exports.hasCurrentThreadProjectionShapeV1 = hasCurrentThreadProjectionShapeV1;
 const canonical_1 = require("./protocol/canonical");
+exports.CURRENT_THREAD_PROJECTION_DIGEST_VERSION_V1 = 2;
 class ThreadProjectionInvariantError extends Error {
     constructor(message, seq, eventType) {
         super(`Thread projection invariant failed at seq ${seq} (${eventType}): ${message}`);
@@ -187,6 +191,43 @@ function verifyThreadProjectionDigest(projection) {
     void _digest;
     return (0, canonical_1.digestRuntimeValue)(content) === projection.digest;
 }
+/**
+ * Compute one explicitly versioned digest without weakening projection-file
+ * integrity. This is used only for immutable cutover-prefix compatibility.
+ */
+function threadProjectionDigestForVersionV1(projection, version) {
+    const { digest: _digest, diagnosticEvents: _diagnosticEvents, compactEvents: _compactEvents, ...legacyContent } = projection;
+    void _digest;
+    void _diagnosticEvents;
+    void _compactEvents;
+    if (version === 1)
+        return (0, canonical_1.digestRuntimeValue)(legacyContent);
+    const content = {
+        ...legacyContent,
+        diagnosticEvents: projection.diagnosticEvents ?? {},
+        compactEvents: projection.compactEvents ?? [],
+    };
+    return (0, canonical_1.digestRuntimeValue)(content);
+}
+/** Resolve an exact known digest scheme; missing metadata is inferred safely. */
+function resolveThreadProjectionDigestVersionV1(projection, digest, requestedVersion) {
+    if (requestedVersion !== undefined) {
+        if (requestedVersion !== 1 && requestedVersion !== 2)
+            return undefined;
+        return threadProjectionDigestForVersionV1(projection, requestedVersion) === digest
+            ? requestedVersion
+            : undefined;
+    }
+    for (const version of [exports.CURRENT_THREAD_PROJECTION_DIGEST_VERSION_V1, 1]) {
+        if (threadProjectionDigestForVersionV1(projection, version) === digest)
+            return version;
+    }
+    return undefined;
+}
+/** Older persisted projections must be rebuilt before incremental advance. */
+function hasCurrentThreadProjectionShapeV1(projection) {
+    return projection.diagnosticEvents !== undefined && projection.compactEvents !== undefined;
+}
 function startTurn(state, event) {
     const turnId = requiredIdentity(event.turnId, 'turnId', event);
     if (state.activeTurnId)

package/dist/runtime/tool-output-presentation.js

@@ -23,11 +23,7 @@ exports.DEFAULT_TOOL_OUTPUT_POLICY = {
 // ============================================================================
 // Known noisy aggregate tool names — always collapsed.
 // ============================================================================
-const ALWAYS_COLLAPSE_TOOLS = new Set([
-    'batch_read',
-    'batch_write',
-    'batch_edit',
-]);
+const ALWAYS_COLLAPSE_TOOLS = new Set(['batch_read', 'batch_write', 'batch_edit']);
 function createToolOutputView(input) {
     const { toolName, success, summary, rawOutput, outputBytes, callId, sequence, policy } = input;
     const contentKind = classifyContent(toolName, rawOutput);
@@ -85,7 +81,7 @@ function createToolOutputView(input) {
     return aggregate ? { ...view, contentKind: 'batch', aggregate } : view;
 }
 function computeAdaptiveView(input) {
-    const { toolName, success, defaultSummary, sanitized, outputBytes, outputLines, detailRef, policy } = input;
+    const { toolName, success, defaultSummary, sanitized, outputBytes, outputLines, detailRef, policy, } = input;
     // Empty output.
     if (!sanitized || outputBytes === 0) {
         return {
@@ -324,6 +320,10 @@ function firstString(...values) {
     return values.find(value => typeof value === 'string' && value.trim().length > 0);
 }
 function summarizeOutput(output) {
-    return output.split(/\r?\n/u).find(line => line.trim())?.trim().slice(0, 160) ?? '';
+    return (output
+        .split(/\r?\n/u)
+        .find(line => line.trim())
+        ?.trim()
+        .slice(0, 160) ?? '');
 }
 //# sourceMappingURL=tool-output-presentation.js.map

package/dist/runtime/turn-controller.js

@@ -81,8 +81,7 @@ class TurnController {
         };
     }
     registerExitIntent(now = Date.now()) {
-        const shouldExit = this.lastExitIntentAt > 0 &&
-            now - this.lastExitIntentAt <= this.exitConfirmWindowMs;
+        const shouldExit = this.lastExitIntentAt > 0 && now - this.lastExitIntentAt <= this.exitConfirmWindowMs;
         this.lastExitIntentAt = shouldExit ? 0 : now;
         return shouldExit;
     }

package/dist/services/auth/auth.js

@@ -200,10 +200,7 @@ function loadOrCreateKey() {
 function encryptMap(plain, key) {
     const iv = (0, crypto_1.randomBytes)(12);
     const cipher = (0, crypto_1.createCipheriv)('aes-256-gcm', key, iv);
-    const ciphertext = Buffer.concat([
-        cipher.update(JSON.stringify(plain), 'utf-8'),
-        cipher.final(),
-    ]);
+    const ciphertext = Buffer.concat([cipher.update(JSON.stringify(plain), 'utf-8'), cipher.final()]);
     const blob = {
         v: 1,
         iv: iv.toString('base64'),

package/dist/services/auth/aws.js

@@ -87,14 +87,16 @@ async function verifyAwsCredentials(auth) {
     if (credentialContext.error)
         return { success: false, error: credentialContext.error };
     // 尝试调用 AWS CLI
-    return new Promise((resolve) => {
+    return new Promise(resolve => {
         const region = auth.region || 'us-east-1';
         (0, child_process_1.execFile)('aws', [
             'sts',
             'get-caller-identity',
             ...credentialContext.profileArgs,
-            '--region', region,
-            '--output', 'json',
+            '--region',
+            region,
+            '--output',
+            'json',
         ], {
             timeout: 10000,
             env: credentialContext.env,
@@ -136,15 +138,18 @@ async function getStsToken(auth, durationSeconds = 3600) {
     const credentialContext = resolveCredentialContext(auth);
     if (credentialContext.error)
         return { success: false, error: credentialContext.error };
-    return new Promise((resolve) => {
+    return new Promise(resolve => {
         const region = auth.region || 'us-east-1';
         (0, child_process_1.execFile)('aws', [
             'sts',
             'get-session-token',
             ...credentialContext.profileArgs,
-            '--region', region,
-            '--duration-seconds', String(durationSeconds),
-            '--output', 'json',
+            '--region',
+            region,
+            '--duration-seconds',
+            String(durationSeconds),
+            '--output',
+            'json',
         ], {
             timeout: 15000,
             env: credentialContext.env,
@@ -183,13 +188,18 @@ async function assumeAwsRole(auth, roleArn, durationSeconds = 3600) {
         (0, child_process_1.execFile)('aws', [
             'sts',
             'assume-role',
-            '--role-arn', roleArn,
-            '--role-session-name', sessionName,
+            '--role-arn',
+            roleArn,
+            '--role-session-name',
+            sessionName,
             ...externalIdArgs,
             ...credentialContext.profileArgs,
-            '--region', region,
-            '--duration-seconds', String(durationSeconds),
-            '--output', 'json',
+            '--region',
+            region,
+            '--duration-seconds',
+            String(durationSeconds),
+            '--output',
+            'json',
         ], {
             timeout: 15000,
             env: credentialContext.env,
@@ -212,10 +222,10 @@ async function assumeAwsRole(auth, roleArn, durationSeconds = 3600) {
  * 检测 AWS CLI 是否可用
  */
 async function checkAwsCliAvailable() {
-    return new Promise((resolve) => {
+    return new Promise(resolve => {
         (0, child_process_1.execFile)('aws', ['--version'], {
             timeout: 5000,
-        }, (error) => {
+        }, error => {
             resolve(!error);
         });
     });

package/dist/services/auto-fix/autoFixRunner.js

@@ -104,7 +104,7 @@ class AutoFixRunner {
     // 内部方法
     // ============================================================================
     async runCommand(command) {
-        return new Promise((resolve) => {
+        return new Promise(resolve => {
             const [cmd, ...args] = command.split(' ');
             (0, child_process_1.execFile)(cmd, args, {
                 cwd: this.projectPath,

package/dist/services/auto-fix/index.d.ts

@@ -3,5 +3,5 @@
  */
 export { AutoFixRunner, getAutoFixRunner, resetAutoFixRunner, type AutoFixResult, type AutoFixError, type AutoFixContext, } from './autoFixRunner';
 export { DEFAULT_AUTOFIX_CONFIG, detectAutoFixConfig, type AutoFixConfig, type AutoFixTrigger, } from './autoFixConfig';
-export { autoFixHook, shouldTriggerAutoFix, } from './autoFixHook';
+export { autoFixHook, shouldTriggerAutoFix } from './autoFixHook';
 //# sourceMappingURL=index.d.ts.map

package/dist/services/diagnostic-tracking/diagnosticTracking.js

@@ -105,8 +105,10 @@ class DiagnosticTracker {
             currentCount: this.currentDiagnostics.length,
             newCount: this.newDiagnostics.length,
             resolvedCount: this.resolvedDiagnostics.length,
-            errorCount: this.currentDiagnostics.filter(d => d.severity === types_1.DiagnosticSeverity.Error).length,
-            warningCount: this.currentDiagnostics.filter(d => d.severity === types_1.DiagnosticSeverity.Warning).length,
+            errorCount: this.currentDiagnostics.filter(d => d.severity === types_1.DiagnosticSeverity.Error)
+                .length,
+            warningCount: this.currentDiagnostics.filter(d => d.severity === types_1.DiagnosticSeverity.Warning)
+                .length,
         };
     }
     /**

package/dist/services/diagnostic-tracking/index.d.ts

@@ -3,5 +3,5 @@
  */
 export { DiagnosticTracker, getDiagnosticTracker, resetDiagnosticTracker, } from './diagnosticTracking';
 export { Diagnostic, DiagnosticBaseline, DiagnosticSeverity, NewDiagnosticsResult, diagnosticKey, isDiagnosticEqual, } from './types';
-export { formatDiagnostic, formatDiagnostics, formatDiagnosticSummary, } from './formatter';
+export { formatDiagnostic, formatDiagnostics, formatDiagnosticSummary } from './formatter';
 //# sourceMappingURL=index.d.ts.map

package/dist/services/effort.js

@@ -5,15 +5,7 @@ exports.isEffortPreference = isEffortPreference;
 exports.resolveEffort = resolveEffort;
 exports.buildProviderEffortParams = buildProviderEffortParams;
 exports.resolveProfileEffort = resolveProfileEffort;
-exports.EFFORT_LEVELS = [
-    'none',
-    'minimal',
-    'low',
-    'medium',
-    'high',
-    'xhigh',
-    'max',
-];
+exports.EFFORT_LEVELS = ['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
 function isEffortPreference(value) {
     return value === 'auto' || exports.EFFORT_LEVELS.includes(value);
 }

package/dist/services/file-glob.js

@@ -24,7 +24,8 @@ function parseGitignore(cwd) {
     if ((0, fs_1.existsSync)(gitignorePath)) {
         try {
             const content = (0, fs_1.readFileSync)(gitignorePath, 'utf-8');
-            const lines = content.split('\n')
+            const lines = content
+                .split('\n')
                 .map(line => line.trim())
                 .filter(line => line && !line.startsWith('#'));
             patterns.push(...lines);
@@ -88,9 +89,7 @@ function matchFiles(query, cwd, options = {}) {
         }
         const entries = (0, fs_1.readdirSync)(dirPath);
         for (const entry of entries) {
-            const entryPath = parts.length > 1
-                ? parts.slice(0, -1).join('/') + '/' + entry
-                : entry;
+            const entryPath = parts.length > 1 ? parts.slice(0, -1).join('/') + '/' + entry : entry;
             // 过滤
             const comparableEntry = caseSensitive ? entry : entry.toLowerCase();
             if (normalizedFilter && !comparableEntry.startsWith(normalizedFilter)) {

package/dist/services/mcp/transports.js

@@ -68,7 +68,7 @@ class SseTransport extends BaseTransport {
             this.reconnectAttempts = 0;
             this.emitConnected();
         };
-        this.eventSource.onmessage = (event) => {
+        this.eventSource.onmessage = event => {
             try {
                 const msg = JSON.parse(event.data);
                 this.emitMessage(msg);
@@ -159,7 +159,7 @@ class WebSocketTransport extends BaseTransport {
                 this.emitConnected();
                 resolve();
             };
-            this.ws.onmessage = (event) => {
+            this.ws.onmessage = event => {
                 try {
                     const msg = JSON.parse(event.data);
                     this.emitMessage(msg);
@@ -168,7 +168,7 @@ class WebSocketTransport extends BaseTransport {
                     this.emitError(new Error(`Failed to parse WebSocket message: ${err}`));
                 }
             };
-            this.ws.onerror = (err) => {
+            this.ws.onerror = err => {
                 this.emitError(new Error('WebSocket error'));
                 reject(err);
             };
@@ -274,7 +274,7 @@ class HttpTransport extends BaseTransport {
             if (!response.ok) {
                 throw new Error(`HTTP ${response.status}: ${response.statusText}`);
             }
-            const data = await response.json();
+            const data = (await response.json());
             this.emitMessage(data);
         }
         catch (err) {