cwtools-mcp 0.1.0

package/dist/hosts/projectSettings.js

@@ -0,0 +1,265 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExtensionSetting = getExtensionSetting;
+exports.readIgnoredDiagnostics = readIgnoredDiagnostics;
+exports.resolveLocalisationLanguages = resolveLocalisationLanguages;
+exports.resolveGeneratedStrings = resolveGeneratedStrings;
+exports.resolveExperimental = resolveExperimental;
+exports.applyDiagnosticIgnoreList = applyDiagnosticIgnoreList;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function parseJsonc(text) {
+    const s = text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
+    let out = '';
+    let i = 0;
+    const n = s.length;
+    let pendingCommaAt = -1; // index in `out` of a comma that may be trailing
+    const dropPendingIfClosing = (ch) => {
+        if (pendingCommaAt >= 0) {
+            if (ch === '}' || ch === ']')
+                out = out.slice(0, pendingCommaAt) + out.slice(pendingCommaAt + 1);
+            pendingCommaAt = -1;
+        }
+    };
+    while (i < n) {
+        const c = s[i];
+        if (c === '"') {
+            dropPendingIfClosing(c);
+            out += c;
+            i++;
+            while (i < n) {
+                const d = s[i];
+                out += d;
+                i++;
+                if (d === '\\') {
+                    out += s[i] ?? '';
+                    i++;
+                    continue;
+                }
+                if (d === '"')
+                    break;
+            }
+            continue;
+        }
+        if (c === '/' && s[i + 1] === '/') {
+            i += 2;
+            while (i < n && s[i] !== '\n')
+                i++;
+            continue;
+        }
+        if (c === '/' && s[i + 1] === '*') {
+            i += 2;
+            while (i < n && !(s[i] === '*' && s[i + 1] === '/'))
+                i++;
+            i += 2;
+            continue;
+        }
+        if (c === ' ' || c === '\t' || c === '\r' || c === '\n') {
+            out += c;
+            i++;
+            continue;
+        }
+        if (c === ',') {
+            pendingCommaAt = out.length;
+            out += c;
+            i++;
+            continue;
+        }
+        dropPendingIfClosing(c);
+        out += c;
+        i++;
+    }
+    return JSON.parse(out);
+}
+const cache = new Map();
+const SETTINGS_NAMESPACE = 'stellarisLanguageServices';
+const LEGACY_SETTINGS_NAMESPACE = 'cwtools';
+function readSettingsObject(workspaceRoot) {
+    const file = path.join(workspaceRoot, '.vscode', 'settings.json');
+    let mtimeMs;
+    try {
+        mtimeMs = fs.statSync(file).mtimeMs;
+    }
+    catch {
+        cache.delete(file);
+        return undefined;
+    }
+    const cached = cache.get(file);
+    if (cached && cached.mtimeMs === mtimeMs)
+        return cached.settings;
+    let settings;
+    try {
+        const parsed = parseJsonc(fs.readFileSync(file, 'utf8'));
+        settings = parsed && typeof parsed === 'object' ? parsed : undefined;
+    }
+    catch {
+        settings = undefined;
+    }
+    cache.set(file, { mtimeMs, settings });
+    return settings;
+}
+function resolveDotted(obj, fullKey) {
+    if (fullKey in obj)
+        return obj[fullKey];
+    const segs = fullKey.split('.');
+    for (let i = 1; i < segs.length; i++) {
+        const head = segs.slice(0, i).join('.');
+        if (head in obj) {
+            const child = obj[head];
+            if (child && typeof child === 'object') {
+                const r = resolveDotted(child, segs.slice(i).join('.'));
+                if (r !== undefined)
+                    return r;
+            }
+        }
+    }
+    return undefined;
+}
+function getExtensionSetting(workspaceRoot, subKey) {
+    const settings = readSettingsObject(workspaceRoot);
+    if (!settings)
+        return undefined;
+    const current = resolveDotted(settings, `${SETTINGS_NAMESPACE}.${subKey}`);
+    return current !== undefined
+        ? current
+        : resolveDotted(settings, `${LEGACY_SETTINGS_NAMESPACE}.${subKey}`);
+}
+function asNonEmptyStringArray(value) {
+    return Array.isArray(value)
+        ? value.filter((v) => typeof v === 'string' && v.length > 0)
+        : [];
+}
+function readIgnoredDiagnostics(workspaceRoot) {
+    return asNonEmptyStringArray(getExtensionSetting(workspaceRoot, 'ai.ignoredDiagnostics'));
+}
+const LANG_TAG_MAP = [
+    ['English', 'english'],
+    ['French', 'french'],
+    ['German', 'german'],
+    ['Spanish', 'spanish'],
+    ['Russian', 'russian'],
+    ['Braz_Por', 'braz_por'],
+    ['Polish', 'polish'],
+    ['Chinese', 'simp_chinese'],
+    ['Korean', 'korean'],
+    ['Japanese', 'japanese'],
+    ['Turkish', 'turkish'],
+];
+const LOC_DIRS = ['localisation', 'localisation_synced', 'localization'];
+const MAX_LOC_FILES = 5000;
+// Count localisation files by language tag and return the dominant non-English
+// language, or undefined (English is the server default). Bounded recursive scan.
+function detectLocalisationLanguage(workspaceRoot) {
+    const counts = new Map();
+    let scanned = 0;
+    const visit = (dir) => {
+        if (scanned >= MAX_LOC_FILES)
+            return;
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (scanned >= MAX_LOC_FILES)
+                return;
+            const full = path.join(dir, e.name);
+            if (e.isDirectory()) {
+                visit(full);
+            }
+            else if (e.isFile() && e.name.toLowerCase().endsWith('.yml')) {
+                scanned++;
+                const base = e.name.toLowerCase();
+                for (const [name, tag] of LANG_TAG_MAP) {
+                    if (base.endsWith(`l_${tag}.yml`)) {
+                        counts.set(name, (counts.get(name) ?? 0) + 1);
+                        break;
+                    }
+                }
+            }
+        }
+    };
+    for (const d of LOC_DIRS)
+        visit(path.join(workspaceRoot, d));
+    let best;
+    let bestCount = 0;
+    for (const [name, count] of counts) {
+        if (count > bestCount) {
+            bestCount = count;
+            best = name;
+        }
+    }
+    return best && best !== 'English' ? best : undefined;
+}
+function resolveLocalisationLanguages(workspaceRoot) {
+    const fromSettings = asNonEmptyStringArray(getExtensionSetting(workspaceRoot, 'localisation.languages'));
+    if (fromSettings.length > 0)
+        return { languages: fromSettings, source: 'settings' };
+    const detected = detectLocalisationLanguage(workspaceRoot);
+    if (detected)
+        return { languages: [detected], source: 'detected' };
+    return { languages: ['English'], source: 'default' };
+}
+function resolveGeneratedStrings(workspaceRoot) {
+    const v = getExtensionSetting(workspaceRoot, 'localisation.generated_strings');
+    return typeof v === 'string' && v.length > 0 ? v : 'replace';
+}
+// `stellarisLanguageServices.experimental` setting. Defaults ON for the MCP: it gates the incremental
+// scripted-type refresh, which lets revalidation of scripted_triggers/effects/values
+// patch the type index in milliseconds instead of triggering a full reload — so
+// definition-file edits don't mis-report references. Honor an explicit opt-out.
+function resolveExperimental(workspaceRoot) {
+    const v = getExtensionSetting(workspaceRoot, 'experimental');
+    return typeof v === 'boolean' ? v : true;
+}
+function applyDiagnosticIgnoreList(result, ignored) {
+    if (!result.ok || result.diagnostics.length === 0 || ignored.length === 0)
+        return result;
+    const kept = result.diagnostics.filter(d => !ignored.some(key => d.message.includes(key)));
+    const suppressed = result.diagnostics.length - kept.length;
+    if (suppressed === 0)
+        return result;
+    return {
+        ...result,
+        diagnostics: kept,
+        suppressedCount: (result.suppressedCount ?? 0) + suppressed,
+        totalCount: typeof result.totalCount === 'number'
+            ? Math.max(0, result.totalCount - suppressed)
+            : result.totalCount,
+    };
+}

package/dist/hosts/revalidation.d.ts

@@ -0,0 +1,12 @@
+import type { LspHost } from 'cwtools-shared';
+export declare class RevalidationCoordinator {
+    private readonly lsp;
+    private readonly workspaceRoot;
+    private readonly readyAt;
+    private readonly lastReval;
+    constructor(lsp: LspHost, workspaceRoot: string, readyAt: () => number | undefined);
+    ensureFresh(absFile?: string): Promise<void>;
+    private changedSingle;
+    private changedAll;
+    private waitDrained;
+}

package/dist/hosts/revalidation.js

@@ -0,0 +1,157 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RevalidationCoordinator = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const lspProcessHost_1 = require("./lspProcessHost");
+// File extensions the language server validates — only these are worth revalidating.
+const REVALIDATE_EXTS = new Set(['.txt', '.yml', '.gui', '.gfx', '.asset', '.shader', '.fxh']);
+const SKIP_DIRS = new Set(['node_modules', 'dist', 'coverage', '.git', '.cwtools', '.cwtools-ai', '.vscode']);
+const MAX_WALK_FILES = 20000;
+const MAX_BATCH = 200;
+function numberOr(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+}
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+class RevalidationCoordinator {
+    constructor(lsp, workspaceRoot, readyAt) {
+        this.lsp = lsp;
+        this.workspaceRoot = workspaceRoot;
+        this.readyAt = readyAt;
+        this.lastReval = new Map();
+    }
+    // absFile: absolute path for a single-file query, or undefined for whole-project.
+    async ensureFresh(absFile) {
+        const baseline = this.readyAt();
+        if (baseline === undefined)
+            return; // server still loading; its load is the freshest state we have
+        const changed = absFile ? this.changedSingle(absFile, baseline) : this.changedAll(baseline);
+        if (changed.length === 0)
+            return;
+        const batch = changed.slice(0, MAX_BATCH);
+        const uris = batch.map(c => (0, lspProcessHost_1.pathToFileUri)(c.path));
+        let baselineEpoch = 0;
+        try {
+            const res = await this.lsp.executeCommand('cwtools.ai.revalidateFiles', [uris], { timeoutMs: 10000 });
+            if (!res || res.ok !== true)
+                return; // older server without the command → plain read
+            baselineEpoch = numberOr(res.baselineEpoch, 0);
+        }
+        catch {
+            return;
+        }
+        // Mark seen so unchanged files are skipped next time.
+        for (const c of batch)
+            this.lastReval.set(c.path, c.mtimeMs);
+        await this.waitDrained(baselineEpoch);
+    }
+    changedSingle(absFile, baseline) {
+        let mtimeMs;
+        try {
+            const st = fs.statSync(absFile);
+            if (!st.isFile())
+                return [];
+            mtimeMs = st.mtimeMs;
+        }
+        catch {
+            return [];
+        }
+        const threshold = Math.max(baseline, this.lastReval.get(absFile) ?? 0);
+        return mtimeMs > threshold ? [{ path: absFile, mtimeMs }] : [];
+    }
+    changedAll(baseline) {
+        const out = [];
+        let scanned = 0;
+        const walk = (dir) => {
+            if (out.length >= MAX_BATCH || scanned >= MAX_WALK_FILES)
+                return;
+            let entries;
+            try {
+                entries = fs.readdirSync(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const e of entries) {
+                if (out.length >= MAX_BATCH || scanned >= MAX_WALK_FILES)
+                    return;
+                if (e.isDirectory()) {
+                    if (!SKIP_DIRS.has(e.name) && !e.name.startsWith('.'))
+                        walk(path.join(dir, e.name));
+                    continue;
+                }
+                if (!e.isFile())
+                    continue;
+                if (!REVALIDATE_EXTS.has(path.extname(e.name).toLowerCase()))
+                    continue;
+                scanned++;
+                const abs = path.join(dir, e.name);
+                let mtimeMs;
+                try {
+                    mtimeMs = fs.statSync(abs).mtimeMs;
+                }
+                catch {
+                    continue;
+                }
+                if (mtimeMs > Math.max(baseline, this.lastReval.get(abs) ?? 0))
+                    out.push({ path: abs, mtimeMs });
+            }
+        };
+        walk(this.workspaceRoot);
+        return out;
+    }
+    // Wait until the lint queue drains and the epoch advanced past the revalidation
+    // baseline (so the posted re-lints have completed). Bounded; best-effort.
+    async waitDrained(baselineEpoch) {
+        const timeoutMs = 5000;
+        const intervalMs = 50;
+        let elapsed = 0;
+        await sleep(30); // head start so the lint agent picks up the posted requests
+        while (elapsed < timeoutMs) {
+            const s = await this.lsp.executeCommand('cwtools.ai.getValidationStatus', [], { timeoutMs: 5000 }).catch(() => null);
+            if (!s || typeof s !== 'object')
+                return;
+            const epoch = numberOr(s.epoch, 0);
+            const inProgress = s.inProgress === true;
+            const queue = numberOr(s.queueDepth, 0) + numberOr(s.debounceQueueDepth, 0);
+            if (epoch > baselineEpoch && !inProgress && queue === 0)
+                return;
+            await sleep(intervalMs);
+            elapsed += intervalMs;
+        }
+    }
+}
+exports.RevalidationCoordinator = RevalidationCoordinator;

package/dist/hosts/vscodeCache.d.ts

@@ -0,0 +1,5 @@
+export declare function detectExtensionCacheDir(game: string | undefined): string | undefined;
+export declare function detectInstalledExtensionDir(): string | undefined;
+export declare function detectExtensionServerPath(): string | undefined;
+export declare function detectExtensionBridgeManifestPath(): string | undefined;
+export declare function detectExtensionRulesDir(cacheDir: string | undefined, game: string | undefined): string | undefined;

package/dist/hosts/vscodeCache.js

@@ -0,0 +1,153 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectExtensionCacheDir = detectExtensionCacheDir;
+exports.detectInstalledExtensionDir = detectInstalledExtensionDir;
+exports.detectExtensionServerPath = detectExtensionServerPath;
+exports.detectExtensionBridgeManifestPath = detectExtensionBridgeManifestPath;
+exports.detectExtensionRulesDir = detectExtensionRulesDir;
+const os = __importStar(require("os"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const cwtools_shared_1 = require("cwtools-shared");
+// VS Code-compatible hosts store the extension's built vanilla cache + extracted
+// rules under globalStorage. In standalone mode, when the user doesn't pass
+// --cache, reuse that dir so the MCP rides on a cache the extension already built.
+const PRIMARY_EXTENSION_ID = 'ForeverSkywalker.foreverskywalker-stellaris-cwtools';
+const PRIMARY_EXTENSION_DIR = PRIMARY_EXTENSION_ID.toLowerCase();
+const VSCODE_APP_DIRS = ['Code', 'Code - Insiders', 'VSCodium', 'Cursor', 'Antigravity'];
+function globalStorageBases() {
+    const home = os.homedir();
+    const platform = os.platform();
+    return VSCODE_APP_DIRS.map(app => {
+        if (platform === 'win32') {
+            const appData = process.env.APPDATA ?? path.join(home, 'AppData', 'Roaming');
+            return path.join(appData, app, 'User', 'globalStorage');
+        }
+        if (platform === 'darwin') {
+            return path.join(home, 'Library', 'Application Support', app, 'User', 'globalStorage');
+        }
+        const xdg = process.env.XDG_CONFIG_HOME ?? path.join(home, '.config');
+        return path.join(xdg, app, 'User', 'globalStorage');
+    });
+}
+// The extension's `.cwtools` dir if it holds the built <game>.cwb, else undefined.
+function detectExtensionCacheDir(game) {
+    const cacheFile = (0, cwtools_shared_1.vanillaCacheFileName)(game);
+    if (!cacheFile)
+        return undefined;
+    for (const base of globalStorageBases()) {
+        const dir = path.join(base, PRIMARY_EXTENSION_DIR, '.cwtools');
+        if (fs.existsSync(path.join(dir, cacheFile)))
+            return dir;
+    }
+    return undefined;
+}
+// Installed-extension roots (`~/.vscode/extensions` and variants), where the
+// packaged CWTools server binary lives — so the MCP rides on the same server the
+// user already installed, with no dev checkout required.
+function extensionInstallRoots() {
+    const home = os.homedir();
+    return ['.vscode', '.vscode-insiders', '.vscode-oss', '.cursor', '.vscode-server', '.antigravity'].map(d => path.join(home, d, 'extensions'));
+}
+// Newest installed main extension dir, else undefined.
+function detectInstalledExtensionDir() {
+    let best;
+    for (const root of extensionInstallRoots()) {
+        if (!fs.existsSync(root))
+            continue;
+        for (const name of fs.readdirSync(root)) {
+            if (!name.toLowerCase().startsWith(`${PRIMARY_EXTENSION_DIR}-`))
+                continue;
+            const version = name.slice(PRIMARY_EXTENSION_DIR.length + 1);
+            // String compare is enough to pick the highest semver-ish folder name.
+            if (!best || version > best.version) {
+                best = { dir: path.join(root, name), version };
+            }
+        }
+    }
+    return best?.dir;
+}
+// The packaged server binary inside the installed extension, else undefined.
+function detectExtensionServerPath() {
+    const ext = detectInstalledExtensionDir();
+    if (!ext)
+        return undefined;
+    const platform = os.platform();
+    const exe = platform === 'win32'
+        ? path.join('win-x64', 'CWTools Server.exe')
+        : platform === 'darwin'
+            ? path.join('osx-x64', 'CWTools Server')
+            : path.join('linux-x64', 'CWTools Server');
+    const candidate = path.join(ext, 'bin', 'server', exe);
+    return fs.existsSync(candidate) ? candidate : undefined;
+}
+// The bridge manifest the active extension host writes under
+// globalStorage/<extension>/mcp/bridge-manifest.json. Lets an independently
+// installed (npx / global npm) cwtools-mcp discover the running extension
+// without a --bridge-manifest override.
+function detectExtensionBridgeManifestPath() {
+    for (const base of globalStorageBases()) {
+        const candidate = path.join(base, PRIMARY_EXTENSION_DIR, 'mcp', 'bridge-manifest.json');
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    return undefined;
+}
+// True when dir holds at least one .cwt rule file at its top level.
+function containsRuleFiles(dir) {
+    try {
+        return fs.readdirSync(dir).some(name => name.toLowerCase().endsWith('.cwt'));
+    }
+    catch {
+        return false;
+    }
+}
+function detectExtensionRulesDir(cacheDir, game) {
+    const g = (game ?? 'stellaris').toLowerCase();
+    const roots = [
+        ...(cacheDir ? [cacheDir] : []),
+        ...globalStorageBases().map(base => path.join(base, PRIMARY_EXTENSION_DIR, '.cwtools')),
+    ];
+    for (const root of roots) {
+        const config = path.join(root, g, 'config');
+        if (containsRuleFiles(config))
+            return config;
+        const bare = path.join(root, g);
+        if (containsRuleFiles(bare))
+            return bare;
+    }
+    return undefined;
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './config';
+export * from './hosts/lspProcessHost';
+export * from './hosts/nodeHostServices';
+export * from './mcp/toolHandlers';
+export * from './mcp/toolRegistrar';
+export * from './mcp/resources';
+export * from './mcp/transportHttp';
+export * from './mcp/transportStdio';
+export * from './server';

package/dist/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./config"), exports);
+__exportStar(require("./hosts/lspProcessHost"), exports);
+__exportStar(require("./hosts/nodeHostServices"), exports);
+__exportStar(require("./mcp/toolHandlers"), exports);
+__exportStar(require("./mcp/toolRegistrar"), exports);
+__exportStar(require("./mcp/resources"), exports);
+__exportStar(require("./mcp/transportHttp"), exports);
+__exportStar(require("./mcp/transportStdio"), exports);
+__exportStar(require("./server"), exports);

package/dist/mcp/bridgeProxy.d.ts

@@ -0,0 +1,4 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import type { CwtoolsMcpConfig } from '../config';
+export declare function createBridgeProxyMcpServer(config: CwtoolsMcpConfig): Server;
+export declare function assertBridgeWorkspaceMatches(expectedWorkspaceRoot: string | string[], servedWorkspaceRoot: string, source?: string): void;