@veewo/gitnexus 1.3.11 → 1.4.6-rc

package/dist/core/{kuzu → lbug}/schema.js

@@ -1,5 +1,5 @@
 /**
- * KuzuDB Schema Definitions
+ * LadybugDB Schema Definitions
  *
  * Hybrid Schema:
  * - Separate node tables for each code element type (File, Function, Class, etc.)
@@ -22,20 +22,7 @@ export const NODE_TABLES = [
 // ============================================================================
 export const REL_TABLE_NAME = 'CodeRelation';
 // Valid relation types
-export const REL_TYPES = [
-    'CONTAINS',
-    'DEFINES',
-    'IMPORTS',
-    'CALLS',
-    'EXTENDS',
-    'IMPLEMENTS',
-    'MEMBER_OF',
-    'STEP_IN_PROCESS',
-    'UNITY_COMPONENT_IN',
-    'UNITY_COMPONENT_INSTANCE',
-    'UNITY_RESOURCE_SUMMARY',
-    'UNITY_SERIALIZED_TYPE_IN',
-];
+export const REL_TYPES = ['CONTAINS', 'DEFINES', 'IMPORTS', 'CALLS', 'EXTENDS', 'IMPLEMENTS', 'HAS_METHOD', 'OVERRIDES', 'MEMBER_OF', 'STEP_IN_PROCESS'];
 // ============================================================================
 // EMBEDDING TABLE
 // ============================================================================
@@ -104,6 +91,8 @@ CREATE NODE TABLE Method (
   isExported BOOLEAN,
   content STRING,
   description STRING,
+  parameterCount INT32,
+  returnType STRING,
   PRIMARY KEY (id)
 )`;
 export const CODE_ELEMENT_SCHEMA = `
@@ -229,15 +218,13 @@ CREATE REL TABLE ${REL_TABLE_NAME} (
   FROM Function TO \`Impl\`,
   FROM Function TO Interface,
   FROM Function TO \`Constructor\`,
-  FROM Function TO \`Property\`,
   FROM Function TO \`Const\`,
   FROM Function TO \`Typedef\`,
   FROM Function TO \`Union\`,
+  FROM Function TO \`Property\`,
   FROM Class TO Method,
   FROM Class TO Function,
   FROM Class TO Class,
-  FROM Class TO File,
-  FROM Class TO CodeElement,
   FROM Class TO Interface,
   FROM Class TO Community,
   FROM Class TO \`Template\`,
@@ -253,7 +240,6 @@ CREATE REL TABLE ${REL_TABLE_NAME} (
   FROM Class TO \`Namespace\`,
   FROM Class TO \`Typedef\`,
   FROM Class TO \`Property\`,
-  FROM Class TO \`Delegate\`,
   FROM Method TO Function,
   FROM Method TO Method,
   FROM Method TO Class,
@@ -269,7 +255,6 @@ CREATE REL TABLE ${REL_TABLE_NAME} (
   FROM Method TO Interface,
   FROM Method TO \`Constructor\`,
   FROM Method TO \`Property\`,
-  FROM Method TO \`Delegate\`,
   FROM \`Template\` TO \`Template\`,
   FROM \`Template\` TO Function,
   FROM \`Template\` TO Method,
@@ -290,6 +275,7 @@ CREATE REL TABLE ${REL_TABLE_NAME} (
   FROM Interface TO \`TypeAlias\`,
   FROM Interface TO \`Struct\`,
   FROM Interface TO \`Constructor\`,
+  FROM Interface TO \`Property\`,
   FROM \`Struct\` TO Community,
   FROM \`Struct\` TO \`Trait\`,
   FROM \`Struct\` TO \`Struct\`,
@@ -297,7 +283,13 @@ CREATE REL TABLE ${REL_TABLE_NAME} (
   FROM \`Struct\` TO \`Enum\`,
   FROM \`Struct\` TO Function,
   FROM \`Struct\` TO Method,
+  FROM \`Struct\` TO Interface,
+  FROM \`Struct\` TO \`Constructor\`,
+  FROM \`Struct\` TO \`Property\`,
+  FROM \`Enum\` TO \`Enum\`,
   FROM \`Enum\` TO Community,
+  FROM \`Enum\` TO Class,
+  FROM \`Enum\` TO Interface,
   FROM \`Macro\` TO Community,
   FROM \`Macro\` TO Function,
   FROM \`Macro\` TO Method,
@@ -307,18 +299,26 @@ CREATE REL TABLE ${REL_TABLE_NAME} (
   FROM \`Union\` TO Community,
   FROM \`Namespace\` TO Community,
   FROM \`Namespace\` TO \`Struct\`,
+  FROM \`Trait\` TO Method,
+  FROM \`Trait\` TO \`Constructor\`,
+  FROM \`Trait\` TO \`Property\`,
   FROM \`Trait\` TO Community,
+  FROM \`Impl\` TO Method,
+  FROM \`Impl\` TO \`Constructor\`,
+  FROM \`Impl\` TO \`Property\`,
   FROM \`Impl\` TO Community,
   FROM \`Impl\` TO \`Trait\`,
   FROM \`Impl\` TO \`Struct\`,
   FROM \`Impl\` TO \`Impl\`,
   FROM \`TypeAlias\` TO Community,
   FROM \`TypeAlias\` TO \`Trait\`,
+  FROM \`TypeAlias\` TO Class,
   FROM \`Const\` TO Community,
   FROM \`Static\` TO Community,
   FROM \`Property\` TO Community,
-  FROM \`Property\` TO Class,
-  FROM \`Property\` TO Interface,
+  FROM \`Record\` TO Method,
+  FROM \`Record\` TO \`Constructor\`,
+  FROM \`Record\` TO \`Property\`,
   FROM \`Record\` TO Community,
   FROM \`Delegate\` TO Community,
   FROM \`Annotation\` TO Community,
@@ -338,6 +338,7 @@ CREATE REL TABLE ${REL_TABLE_NAME} (
   FROM \`Constructor\` TO \`Namespace\`,
   FROM \`Constructor\` TO \`Module\`,
   FROM \`Constructor\` TO \`Property\`,
+  FROM \`Constructor\` TO \`Typedef\`,
   FROM \`Template\` TO Community,
   FROM \`Module\` TO Community,
   FROM Function TO Process,

package/dist/core/lbug/schema.test.d.ts

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

package/dist/core/search/bm25-index.d.ts

@@ -1,7 +1,7 @@
 /**
- * Full-Text Search via KuzuDB FTS
+ * Full-Text Search via LadybugDB FTS
  *
- * Uses KuzuDB's built-in full-text search indexes for keyword-based search.
+ * Uses LadybugDB's built-in full-text search indexes for keyword-based search.
  * Always reads from the database (no cached state to drift).
  */
 export interface BM25SearchResult {
@@ -10,7 +10,7 @@ export interface BM25SearchResult {
     rank: number;
 }
 /**
- * Search using KuzuDB's built-in FTS (always fresh, reads from disk)
+ * Search using LadybugDB's built-in FTS (always fresh, reads from disk)
  *
  * Queries multiple node tables (File, Function, Class, Method) in parallel
  * and merges results by filePath, summing scores for the same file.
@@ -20,4 +20,4 @@ export interface BM25SearchResult {
  * @param repoId - If provided, queries will be routed via the MCP connection pool
  * @returns Ranked search results from FTS indexes
  */
-export declare const searchFTSFromKuzu: (query: string, limit?: number, repoId?: string) => Promise<BM25SearchResult[]>;
+export declare const searchFTSFromLbug: (query: string, limit?: number, repoId?: string) => Promise<BM25SearchResult[]>;

package/dist/core/search/bm25-index.js

@@ -1,16 +1,17 @@
 /**
- * Full-Text Search via KuzuDB FTS
+ * Full-Text Search via LadybugDB FTS
  *
- * Uses KuzuDB's built-in full-text search indexes for keyword-based search.
+ * Uses LadybugDB's built-in full-text search indexes for keyword-based search.
  * Always reads from the database (no cached state to drift).
  */
-import { queryFTS } from '../kuzu/kuzu-adapter.js';
+import { queryFTS } from '../lbug/lbug-adapter.js';
 /**
  * Execute a single FTS query via a custom executor (for MCP connection pool).
- * Returns the same shape as core queryFTS.
+ * Returns the same shape as core queryFTS (from LadybugDB adapter).
  */
 async function queryFTSViaExecutor(executor, tableName, indexName, query, limit) {
-    const escapedQuery = query.replace(/'/g, "''");
+    // Escape single quotes and backslashes to prevent Cypher injection
+    const escapedQuery = query.replace(/\\/g, '\\\\').replace(/'/g, "''");
     const cypher = `
     CALL QUERY_FTS_INDEX('${tableName}', '${indexName}', '${escapedQuery}', conjunctive := false)
     RETURN node, score
@@ -33,7 +34,7 @@ async function queryFTSViaExecutor(executor, tableName, indexName, query, limit)
     }
 }
 /**
- * Search using KuzuDB's built-in FTS (always fresh, reads from disk)
+ * Search using LadybugDB's built-in FTS (always fresh, reads from disk)
  *
  * Queries multiple node tables (File, Function, Class, Method) in parallel
  * and merges results by filePath, summing scores for the same file.
@@ -43,13 +44,13 @@ async function queryFTSViaExecutor(executor, tableName, indexName, query, limit)
  * @param repoId - If provided, queries will be routed via the MCP connection pool
  * @returns Ranked search results from FTS indexes
  */
-export const searchFTSFromKuzu = async (query, limit = 20, repoId) => {
+export const searchFTSFromLbug = async (query, limit = 20, repoId) => {
     let fileResults, functionResults, classResults, methodResults, interfaceResults;
     if (repoId) {
         // Use MCP connection pool via dynamic import
-        // IMPORTANT: KuzuDB uses a single connection per repo — queries must be sequential
-        // to avoid deadlocking. Do NOT use Promise.all here.
-        const { executeQuery } = await import('../../mcp/core/kuzu-adapter.js');
+        // IMPORTANT: FTS queries run sequentially to avoid connection contention.
+        // The MCP pool supports multiple connections, but FTS is best run serially.
+        const { executeQuery } = await import('../../mcp/core/lbug-adapter.js');
         const executor = (cypher) => executeQuery(repoId, cypher);
         fileResults = await queryFTSViaExecutor(executor, 'File', 'file_fts', query, limit);
         functionResults = await queryFTSViaExecutor(executor, 'Function', 'function_fts', query, limit);
@@ -58,7 +59,7 @@ export const searchFTSFromKuzu = async (query, limit = 20, repoId) => {
         interfaceResults = await queryFTSViaExecutor(executor, 'Interface', 'interface_fts', query, limit);
     }
     else {
-        // Use core kuzu adapter (CLI / pipeline context) — also sequential for safety
+        // Use core lbug adapter (CLI / pipeline context) — also sequential for safety
         fileResults = await queryFTS('File', 'file_fts', query, limit, false).catch(() => []);
         functionResults = await queryFTS('Function', 'function_fts', query, limit, false).catch(() => []);
         classResults = await queryFTS('Class', 'class_fts', query, limit, false).catch(() => []);

package/dist/core/search/hybrid-search.d.ts

@@ -33,7 +33,7 @@ export interface HybridSearchResult {
 export declare const mergeWithRRF: (bm25Results: BM25SearchResult[], semanticResults: SemanticSearchResult[], limit?: number) => HybridSearchResult[];
 /**
  * Check if hybrid search is available
- * KuzuDB FTS is always available once the database is initialized.
+ * LadybugDB FTS is always available once the database is initialized.
  * Semantic search is optional - hybrid works with just FTS if embeddings aren't ready.
  */
 export declare const isHybridSearchReady: () => boolean;
@@ -43,7 +43,7 @@ export declare const isHybridSearchReady: () => boolean;
 export declare const formatHybridResults: (results: HybridSearchResult[]) => string;
 /**
  * Execute BM25 + semantic search and merge with RRF.
- * Uses KuzuDB FTS for always-fresh BM25 results (no cached data).
+ * Uses LadybugDB FTS for always-fresh BM25 results (no cached data).
  * The semanticSearch function is injected to keep this module environment-agnostic.
  */
 export declare const hybridSearch: (query: string, limit: number, executeQuery: (cypher: string) => Promise<any[]>, semanticSearch: (executeQuery: (cypher: string) => Promise<any[]>, query: string, k?: number) => Promise<SemanticSearchResult[]>) => Promise<HybridSearchResult[]>;

package/dist/core/search/hybrid-search.js

@@ -7,7 +7,7 @@
  * This is the same approach used by Elasticsearch, Pinecone, and other
  * production search systems.
  */
-import { searchFTSFromKuzu } from './bm25-index.js';
+import { searchFTSFromLbug } from './bm25-index.js';
 /**
  * RRF constant - standard value used in the literature
  * Higher values give more weight to lower-ranked results
@@ -80,11 +80,11 @@ export const mergeWithRRF = (bm25Results, semanticResults, limit = 10) => {
 };
 /**
  * Check if hybrid search is available
- * KuzuDB FTS is always available once the database is initialized.
+ * LadybugDB FTS is always available once the database is initialized.
  * Semantic search is optional - hybrid works with just FTS if embeddings aren't ready.
  */
 export const isHybridSearchReady = () => {
-    return true; // FTS is always available via KuzuDB when DB is open
+    return true; // FTS is always available via LadybugDB when DB is open
 };
 /**
  * Format hybrid results for LLM consumption
@@ -107,12 +107,12 @@ export const formatHybridResults = (results) => {
 };
 /**
  * Execute BM25 + semantic search and merge with RRF.
- * Uses KuzuDB FTS for always-fresh BM25 results (no cached data).
+ * Uses LadybugDB FTS for always-fresh BM25 results (no cached data).
  * The semanticSearch function is injected to keep this module environment-agnostic.
  */
 export const hybridSearch = async (query, limit, executeQuery, semanticSearch) => {
-    // Use KuzuDB FTS for always-fresh BM25 results
-    const bm25Results = await searchFTSFromKuzu(query, limit);
+    // Use LadybugDB FTS for always-fresh BM25 results
+    const bm25Results = await searchFTSFromLbug(query, limit);
     const semanticResults = await semanticSearch(executeQuery, query, limit);
     return mergeWithRRF(bm25Results, semanticResults, limit);
 };

package/dist/core/tree-sitter/parser-loader.d.ts

@@ -1,4 +1,5 @@
 import Parser from 'tree-sitter';
 import { SupportedLanguages } from '../../config/supported-languages.js';
+export declare const isLanguageAvailable: (language: SupportedLanguages) => boolean;
 export declare const loadParser: () => Promise<Parser>;
 export declare const loadLanguage: (language: SupportedLanguages, filePath?: string) => Promise<void>;

package/dist/core/tree-sitter/parser-loader.js

@@ -9,7 +9,22 @@ import CSharp from 'tree-sitter-c-sharp';
 import Go from 'tree-sitter-go';
 import Rust from 'tree-sitter-rust';
 import PHP from 'tree-sitter-php';
+import Ruby from 'tree-sitter-ruby';
+import { createRequire } from 'node:module';
 import { SupportedLanguages } from '../../config/supported-languages.js';
+// tree-sitter-swift is an optionalDependency — may not be installed
+const _require = createRequire(import.meta.url);
+let Swift = null;
+try {
+    Swift = _require('tree-sitter-swift');
+}
+catch { }
+// tree-sitter-kotlin is an optionalDependency — may not be installed
+let Kotlin = null;
+try {
+    Kotlin = _require('tree-sitter-kotlin');
+}
+catch { }
 let parser = null;
 const languageMap = {
     [SupportedLanguages.JavaScript]: JavaScript,
@@ -22,8 +37,12 @@ const languageMap = {
     [SupportedLanguages.CSharp]: CSharp,
     [SupportedLanguages.Go]: Go,
     [SupportedLanguages.Rust]: Rust,
+    ...(Kotlin ? { [SupportedLanguages.Kotlin]: Kotlin } : {}),
     [SupportedLanguages.PHP]: PHP.php_only,
+    [SupportedLanguages.Ruby]: Ruby,
+    ...(Swift ? { [SupportedLanguages.Swift]: Swift } : {}),
 };
+export const isLanguageAvailable = (language) => language in languageMap;
 export const loadParser = async () => {
     if (parser)
         return parser;

package/dist/core/wiki/generator.d.ts

@@ -36,14 +36,14 @@ export declare class WikiGenerator {
     private repoPath;
     private storagePath;
     private wikiDir;
-    private kuzuPath;
+    private lbugPath;
     private llmConfig;
     private maxTokensPerModule;
     private concurrency;
     private options;
     private onProgress;
     private failedModules;
-    constructor(repoPath: string, storagePath: string, kuzuPath: string, llmConfig: LLMConfig, options?: WikiOptions, onProgress?: ProgressCallback);
+    constructor(repoPath: string, storagePath: string, lbugPath: string, llmConfig: LLMConfig, options?: WikiOptions, onProgress?: ProgressCallback);
     private lastPercent;
     /**
      * Create streaming options that report LLM progress to the progress bar.

package/dist/core/wiki/generator.js

@@ -11,7 +11,7 @@
  */
 import fs from 'fs/promises';
 import path from 'path';
-import { execSync } from 'child_process';
+import { execSync, execFileSync } from 'child_process';
 import { initWikiDb, closeWikiDb, getFilesWithExports, getAllFiles, getIntraModuleCallEdges, getInterModuleCallEdges, getProcessesForFiles, getAllProcesses, getInterModuleEdgesForOverview, } from './graph-queries.js';
 import { generateHTMLViewer } from './html-viewer.js';
 import { callLLM, estimateTokens, } from './llm-client.js';
@@ -25,18 +25,18 @@ export class WikiGenerator {
     repoPath;
     storagePath;
     wikiDir;
-    kuzuPath;
+    lbugPath;
     llmConfig;
     maxTokensPerModule;
     concurrency;
     options;
     onProgress;
     failedModules = [];
-    constructor(repoPath, storagePath, kuzuPath, llmConfig, options = {}, onProgress) {
+    constructor(repoPath, storagePath, lbugPath, llmConfig, options = {}, onProgress) {
         this.repoPath = repoPath;
         this.storagePath = storagePath;
         this.wikiDir = path.join(storagePath, WIKI_DIR);
-        this.kuzuPath = kuzuPath;
+        this.lbugPath = lbugPath;
         this.options = options;
         this.llmConfig = llmConfig;
         this.maxTokensPerModule = options.maxTokensPerModule ?? DEFAULT_MAX_TOKENS_PER_MODULE;
@@ -95,7 +95,7 @@ export class WikiGenerator {
         }
         // Init graph
         this.onProgress('init', 2, 'Connecting to knowledge graph...');
-        await initWikiDb(this.kuzuPath);
+        await initWikiDb(this.lbugPath);
         let result;
         try {
             if (!forceMode && existingMeta && existingMeta.fromCommit) {
@@ -561,7 +561,7 @@ export class WikiGenerator {
     }
     getChangedFiles(fromCommit, toCommit) {
         try {
-            const output = execSync(`git diff ${fromCommit}..${toCommit} --name-only`, { cwd: this.repoPath }).toString().trim();
+            const output = execFileSync('git', ['diff', `${fromCommit}..${toCommit}`, '--name-only'], { cwd: this.repoPath }).toString().trim();
             return output ? output.split('\n').filter(Boolean) : [];
         }
         catch {

package/dist/core/wiki/graph-queries.d.ts

@@ -2,7 +2,7 @@
  * Graph Queries for Wiki Generation
  *
  * Encapsulated Cypher queries against the GitNexus knowledge graph.
- * Uses the MCP-style pooled kuzu-adapter for connection management.
+ * Uses the MCP-style pooled lbug-adapter for connection management.
  */
 export interface FileWithExports {
     filePath: string;
@@ -30,11 +30,11 @@ export interface ProcessInfo {
     }>;
 }
 /**
- * Initialize the KuzuDB connection for wiki generation.
+ * Initialize the LadybugDB connection for wiki generation.
  */
-export declare function initWikiDb(kuzuPath: string): Promise<void>;
+export declare function initWikiDb(lbugPath: string): Promise<void>;
 /**
- * Close the KuzuDB connection.
+ * Close the LadybugDB connection.
  */
 export declare function closeWikiDb(): Promise<void>;
 /**

package/dist/core/wiki/graph-queries.js

@@ -2,21 +2,21 @@
  * Graph Queries for Wiki Generation
  *
  * Encapsulated Cypher queries against the GitNexus knowledge graph.
- * Uses the MCP-style pooled kuzu-adapter for connection management.
+ * Uses the MCP-style pooled lbug-adapter for connection management.
  */
-import { initKuzu, executeQuery, closeKuzu } from '../../mcp/core/kuzu-adapter.js';
+import { initLbug, executeQuery, closeLbug } from '../../mcp/core/lbug-adapter.js';
 const REPO_ID = '__wiki__';
 /**
- * Initialize the KuzuDB connection for wiki generation.
+ * Initialize the LadybugDB connection for wiki generation.
  */
-export async function initWikiDb(kuzuPath) {
-    await initKuzu(REPO_ID, kuzuPath);
+export async function initWikiDb(lbugPath) {
+    await initLbug(REPO_ID, lbugPath);
 }
 /**
- * Close the KuzuDB connection.
+ * Close the LadybugDB connection.
  */
 export async function closeWikiDb() {
-    await closeKuzu(REPO_ID);
+    await closeLbug(REPO_ID);
 }
 /**
  * Get all source files with their exported symbol names and types.

package/dist/mcp/compatible-stdio-transport.d.ts

@@ -0,0 +1,25 @@
+import type { Transport, TransportSendOptions } from '@modelcontextprotocol/sdk/shared/transport.js';
+import { type JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
+export type StdioFraming = 'content-length' | 'newline';
+export declare class CompatibleStdioServerTransport implements Transport {
+    private readonly _stdin;
+    private readonly _stdout;
+    private _readBuffer;
+    private _started;
+    private _framing;
+    onmessage?: (message: JSONRPCMessage) => void;
+    onerror?: (error: Error) => void;
+    onclose?: () => void;
+    constructor(_stdin?: NodeJS.ReadableStream, _stdout?: NodeJS.WritableStream);
+    private readonly _ondata;
+    private readonly _onerror;
+    start(): Promise<void>;
+    private detectFraming;
+    private discardBufferedInput;
+    private readContentLengthMessage;
+    private readNewlineMessage;
+    private readMessage;
+    private processReadBuffer;
+    close(): Promise<void>;
+    send(message: JSONRPCMessage, _options?: TransportSendOptions): Promise<void>;
+}

package/dist/mcp/compatible-stdio-transport.js

@@ -0,0 +1,200 @@
+import process from 'node:process';
+import { JSONRPCMessageSchema } from '@modelcontextprotocol/sdk/types.js';
+function deserializeMessage(raw) {
+    return JSONRPCMessageSchema.parse(JSON.parse(raw));
+}
+function serializeNewlineMessage(message) {
+    return `${JSON.stringify(message)}\n`;
+}
+function serializeContentLengthMessage(message) {
+    const body = JSON.stringify(message);
+    return `Content-Length: ${Buffer.byteLength(body, 'utf8')}\r\n\r\n${body}`;
+}
+function findHeaderEnd(buffer) {
+    const crlfEnd = buffer.indexOf('\r\n\r\n');
+    if (crlfEnd !== -1) {
+        return { index: crlfEnd, separatorLength: 4 };
+    }
+    const lfEnd = buffer.indexOf('\n\n');
+    if (lfEnd !== -1) {
+        return { index: lfEnd, separatorLength: 2 };
+    }
+    return null;
+}
+function looksLikeContentLength(buffer) {
+    if (buffer.length < 14) {
+        return false;
+    }
+    const probe = buffer.toString('utf8', 0, Math.min(buffer.length, 32));
+    return /^content-length\s*:/i.test(probe);
+}
+const MAX_BUFFER_SIZE = 10 * 1024 * 1024; // 10 MB — generous for JSON-RPC
+export class CompatibleStdioServerTransport {
+    _stdin;
+    _stdout;
+    _readBuffer;
+    _started = false;
+    _framing = null;
+    onmessage;
+    onerror;
+    onclose;
+    constructor(_stdin = process.stdin, _stdout = process.stdout) {
+        this._stdin = _stdin;
+        this._stdout = _stdout;
+    }
+    _ondata = (chunk) => {
+        this._readBuffer = this._readBuffer ? Buffer.concat([this._readBuffer, chunk]) : chunk;
+        if (this._readBuffer.length > MAX_BUFFER_SIZE) {
+            this.onerror?.(new Error(`Read buffer exceeded maximum size (${MAX_BUFFER_SIZE} bytes)`));
+            this.discardBufferedInput();
+            return;
+        }
+        this.processReadBuffer();
+    };
+    _onerror = (error) => {
+        this.onerror?.(error);
+    };
+    async start() {
+        if (this._started) {
+            throw new Error('CompatibleStdioServerTransport already started!');
+        }
+        this._started = true;
+        this._stdin.on('data', this._ondata);
+        this._stdin.on('error', this._onerror);
+    }
+    detectFraming() {
+        if (!this._readBuffer || this._readBuffer.length === 0) {
+            return null;
+        }
+        const firstByte = this._readBuffer[0];
+        if (firstByte === 0x7b || firstByte === 0x5b) {
+            return 'newline';
+        }
+        if (looksLikeContentLength(this._readBuffer)) {
+            return 'content-length';
+        }
+        return null;
+    }
+    discardBufferedInput() {
+        this._readBuffer = undefined;
+        this._framing = null;
+    }
+    readContentLengthMessage() {
+        if (!this._readBuffer) {
+            return null;
+        }
+        const header = findHeaderEnd(this._readBuffer);
+        if (header === null) {
+            return null;
+        }
+        const headerText = this._readBuffer
+            .toString('utf8', 0, header.index)
+            .replace(/\r\n/g, '\n')
+            .replace(/\r/g, '\n');
+        const match = headerText.match(/(?:^|\n)content-length\s*:\s*(\d+)/i);
+        if (!match) {
+            this.discardBufferedInput();
+            throw new Error('Missing Content-Length header from MCP client');
+        }
+        const contentLength = Number.parseInt(match[1], 10);
+        if (!Number.isFinite(contentLength) || contentLength < 0) {
+            this.discardBufferedInput();
+            throw new Error('Invalid Content-Length header from MCP client');
+        }
+        if (contentLength > MAX_BUFFER_SIZE) {
+            this.discardBufferedInput();
+            throw new Error(`Content-Length ${contentLength} exceeds maximum allowed size (${MAX_BUFFER_SIZE} bytes)`);
+        }
+        const bodyStart = header.index + header.separatorLength;
+        const bodyEnd = bodyStart + contentLength;
+        if (this._readBuffer.length < bodyEnd) {
+            return null;
+        }
+        const body = this._readBuffer.toString('utf8', bodyStart, bodyEnd);
+        this._readBuffer = this._readBuffer.subarray(bodyEnd);
+        return deserializeMessage(body);
+    }
+    readNewlineMessage() {
+        if (!this._readBuffer) {
+            return null;
+        }
+        while (true) {
+            const newlineIndex = this._readBuffer.indexOf('\n');
+            if (newlineIndex === -1) {
+                return null;
+            }
+            const line = this._readBuffer.toString('utf8', 0, newlineIndex).replace(/\r$/, '');
+            this._readBuffer = this._readBuffer.subarray(newlineIndex + 1);
+            if (line.trim().length === 0) {
+                continue;
+            }
+            return deserializeMessage(line);
+        }
+    }
+    readMessage() {
+        if (!this._readBuffer || this._readBuffer.length === 0) {
+            return null;
+        }
+        if (this._framing === null) {
+            this._framing = this.detectFraming();
+            if (this._framing === null) {
+                return null;
+            }
+        }
+        return this._framing === 'content-length'
+            ? this.readContentLengthMessage()
+            : this.readNewlineMessage();
+    }
+    processReadBuffer() {
+        while (true) {
+            try {
+                const message = this.readMessage();
+                if (message === null) {
+                    break;
+                }
+                this.onmessage?.(message);
+            }
+            catch (error) {
+                this.onerror?.(error);
+                break;
+            }
+        }
+    }
+    async close() {
+        this._stdin.off('data', this._ondata);
+        this._stdin.off('error', this._onerror);
+        const remainingDataListeners = this._stdin.listenerCount('data');
+        if (remainingDataListeners === 0) {
+            this._stdin.pause();
+        }
+        this._started = false;
+        this._readBuffer = undefined;
+        this.onclose?.();
+    }
+    send(message, _options) {
+        return new Promise((resolve, reject) => {
+            if (!this._started) {
+                reject(new Error('Transport is closed'));
+                return;
+            }
+            const payload = this._framing === 'newline'
+                ? serializeNewlineMessage(message)
+                : serializeContentLengthMessage(message);
+            const onError = (error) => {
+                this._stdout.removeListener('error', onError);
+                reject(error);
+            };
+            this._stdout.on('error', onError);
+            if (this._stdout.write(payload)) {
+                this._stdout.removeListener('error', onError);
+                resolve();
+            }
+            else {
+                this._stdout.once('drain', () => {
+                    this._stdout.removeListener('error', onError);
+                    resolve();
+                });
+            }
+        });
+    }
+}