cwtools-mcp 0.1.0

package/dist/hosts/nodeHostServices.js

@@ -0,0 +1,506 @@
+"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.createNodeHostServices = createNodeHostServices;
+const fs = __importStar(require("fs/promises"));
+const fssync = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const cwtools_shared_1 = require("cwtools-shared");
+const lspProcessHost_1 = require("./lspProcessHost");
+const projectDetect_1 = require("./projectDetect");
+const projectSettings_1 = require("./projectSettings");
+const revalidation_1 = require("./revalidation");
+const vscodeCache_1 = require("./vscodeCache");
+function createNodeHostServices(config) {
+    const workspaceRoot = path.resolve(config.workspaceRoot);
+    const allowlist = config.allowedTools.length > 0
+        ? new Set(config.allowedTools)
+        : new Set(cwtools_shared_1.MCP_WRITE_TOOL_NAMES);
+    const filesystem = new NodeFilesystemHost(workspaceRoot, config.enableWrites);
+    const support = (0, projectDetect_1.detectProjectSupport)(workspaceRoot);
+    const enabled = support.supported || config.forceStart;
+    // Fall back to the VS Code cwtools extension's globalStorage cache when --cache
+    // is omitted, so the MCP reuses the vanilla cache the extension already built.
+    const autoCache = config.cachePath ?? (0, vscodeCache_1.detectExtensionCacheDir)(config.game);
+    const detectedRulesPath = (0, vscodeCache_1.detectExtensionRulesDir)(autoCache, config.game);
+    const rulesConfigDirs = uniqueStrings([config.rulesPath, detectedRulesPath].filter((item) => !!item));
+    const lspProcess = enabled
+        ? (0, lspProcessHost_1.createLspProcessHost)({
+            workspaceRoot,
+            game: config.game,
+            serverPath: config.serverPath,
+            cachePath: autoCache,
+            gamePath: config.gamePath,
+            bundledRulesPath: config.rulesPath,
+        })
+        : undefined;
+    const lsp = lspProcess
+        ?? (0, cwtools_shared_1.createUnavailableLspHost)('Workspace is not a recognised Paradox mod; CWTools is disabled here.');
+    if (!enabled) {
+        console.error(`[cwtools-mcp] info: tool calls will be rejected (no language server) — ${support.reason} (pass --force-start to override)`);
+    }
+    else if (!support.supported) {
+        console.error(`[cwtools-mcp] info: --force-start set; starting despite: ${support.reason}`);
+    }
+    else if (support.matchedAt && support.matchedAt !== workspaceRoot) {
+        console.error(`[cwtools-mcp] info: mod detected at ${support.matchedAt} (workspace = ${workspaceRoot})`);
+    }
+    if (enabled && !config.cachePath && autoCache) {
+        console.error(`[cwtools-mcp] info: auto-detected VS Code extension cache at ${autoCache}`);
+    }
+    // Surface the resolved workspace so it's clear which mod is analysed — when
+    // --workspace is omitted this is the process cwd Codex launched the server in.
+    console.error(`[cwtools-mcp] info: workspace = ${workspaceRoot}${config.workspaceRoot === process.cwd() ? ' (inherited cwd)' : ''}`);
+    return {
+        workspaceRoot,
+        readonlyMode: !config.enableWrites,
+        writesEnabled: config.enableWrites,
+        allowedWriteTools: allowlist,
+        projectSupported: enabled,
+        projectSupportReason: support.reason,
+        lsp,
+        diagnostics: new LspDiagnosticsHost(lsp, workspaceRoot, lspProcess ? new revalidation_1.RevalidationCoordinator(lsp, workspaceRoot, () => lspProcess.readyAtMs) : undefined),
+        filesystem,
+        indexing: new ThinNodeIndexHost(workspaceRoot),
+        rules: {
+            gameId: config.game,
+            configDirs: rulesConfigDirs,
+            async readTextFile(filePath) {
+                if (!fssync.existsSync(filePath))
+                    return { content: '', hasBom: false, exists: false };
+                const content = await fs.readFile(filePath, 'utf8');
+                return { content, hasBom: content.charCodeAt(0) === 0xfeff, exists: true };
+            },
+            async listCwtFiles(root, options) {
+                const limit = Math.max(1, Math.min(options?.limit ?? 1000, 5000));
+                const results = [];
+                await walk(root, async (filePath) => {
+                    if (results.length >= limit)
+                        return;
+                    if (filePath.toLowerCase().endsWith('.cwt'))
+                        results.push(filePath);
+                });
+                return results;
+            },
+        },
+        vanillaCache: probeVanillaCache(workspaceRoot, { ...config, cachePath: autoCache }),
+        now: () => Date.now(),
+        log: (level, message, data) => {
+            if (level === 'debug')
+                return;
+            const suffix = data === undefined ? '' : ` ${JSON.stringify(data)}`;
+            console.error(`[cwtools-mcp] ${level}: ${message}${suffix}`);
+        },
+        dispose: () => lspProcess?.dispose(),
+    };
+}
+function uniqueStrings(values) {
+    const seen = new Set();
+    const results = [];
+    for (const value of values) {
+        const key = process.platform === 'win32' ? value.toLowerCase() : value;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        results.push(value);
+    }
+    return results;
+}
+// Resolve vanilla-cache availability up front: a pre-built <game>.cwb under the
+// rules-cache root means vanilla data loads; a valid --game-path means the server
+// can build it; otherwise results are mod-only. Mirrors GameLoader.getCachedFiles
+// (cache file lives at the rules-cache root) and Program.fs cache.<game> handling.
+function probeVanillaCache(workspaceRoot, config) {
+    const cacheFileName = (0, cwtools_shared_1.vanillaCacheFileName)(config.game);
+    const rulesCacheRoot = (0, lspProcessHost_1.resolveRulesCacheRoot)({ cachePath: config.cachePath, workspaceRoot });
+    const cacheFile = cacheFileName ? path.join(rulesCacheRoot, cacheFileName) : undefined;
+    const cacheExists = !!cacheFile && fssync.existsSync(cacheFile);
+    const gamePathValid = !!config.gamePath && fssync.existsSync(config.gamePath);
+    if (cacheExists) {
+        return { available: true, source: 'mod_plus_vanilla', cacheFile, reason: 'Loaded a pre-built vanilla cache.' };
+    }
+    if (gamePathValid) {
+        return {
+            available: true,
+            source: 'mod_plus_vanilla',
+            cacheFile,
+            gamePath: config.gamePath,
+            reason: 'No pre-built cache; the server will build one from --game-path on first load (slow).',
+        };
+    }
+    return {
+        available: false,
+        source: 'mod_only',
+        cacheFile,
+        reason: 'No vanilla cache and no --game-path/--cache; results reflect mod files only.',
+    };
+}
+class LspDiagnosticsHost {
+    constructor(lsp, workspaceRoot, revalidation) {
+        this.lsp = lsp;
+        this.workspaceRoot = workspaceRoot;
+        this.revalidation = revalidation;
+    }
+    async getDiagnostics(filter = {}) {
+        if (this.revalidation) {
+            const absFile = filter.file
+                ? (0, cwtools_shared_1.resolveWorkspacePath)(this.workspaceRoot, filter.file).resolvedPath ?? undefined
+                : undefined;
+            await this.revalidation.ensureFresh(absFile);
+        }
+        return this.applyIgnoreList(await this.queryDiagnostics(filter));
+    }
+    applyIgnoreList(result) {
+        if (!result.ok || result.diagnostics.length === 0)
+            return result;
+        return (0, projectSettings_1.applyDiagnosticIgnoreList)(result, (0, projectSettings_1.readIgnoredDiagnostics)(this.workspaceRoot));
+    }
+    async queryDiagnostics(filter) {
+        const file = filter.file;
+        if (file) {
+            const resolution = (0, cwtools_shared_1.resolveWorkspacePath)(this.workspaceRoot, file);
+            const filePath = resolution.resolvedPath ?? file;
+            const raw = asRecord(await this.lsp.executeCommand('cwtools.ai.getDiagnosticsFresh', [(0, lspProcessHost_1.pathToFileUri)(filePath)], { timeoutMs: 20000 }));
+            return normalizeDiagnosticsFresh(raw);
+        }
+        // Whole-workspace: aggregate cached per-file diagnostics from the server. The
+        // server populated these for every file during load; getValidationStatus alone
+        // only reports freshness, never the diagnostics themselves.
+        const severity = filter.severity === 'information' ? 'info' : filter.severity ?? 'all';
+        const limit = typeof filter.limit === 'number' ? filter.limit : 1000;
+        const raw = asRecord(await this.lsp.executeCommand('cwtools.ai.getAllDiagnostics', [severity, limit], { timeoutMs: 30000 }));
+        if (raw.ok === false || raw.status === 'unavailable') {
+            return unavailableDiagnostics(raw);
+        }
+        return {
+            ok: true,
+            status: 'fresh',
+            diagnostics: Array.isArray(raw.diagnostics) ? raw.diagnostics.map(normalizeDiagnosticRecord) : [],
+            totalCount: numberOrUndefined(raw.totalCount),
+            truncated: raw.truncated === true,
+            freshness: {
+                value: 'fresh',
+                pendingKinds: [],
+                epoch: numberOrUndefined(raw.epoch),
+            },
+        };
+    }
+}
+function normalizeDiagnosticsFresh(raw) {
+    if (raw.ok === false || raw.status === 'unavailable') {
+        return unavailableDiagnostics(raw);
+    }
+    const freshness = String(raw.freshness ?? 'unavailable');
+    return {
+        ok: true,
+        status: freshness,
+        diagnostics: Array.isArray(raw.diagnostics) ? raw.diagnostics.map(normalizeDiagnosticRecord) : [],
+        freshness: {
+            value: freshness,
+            pendingKinds: asStringArray(raw.pendingGlobalKinds),
+            validatedVersion: numberOrUndefined(raw.validatedVersion),
+            epoch: numberOrUndefined(raw.epoch),
+            updatedAt: numberOrUndefined(raw.updatedAtUnixMs),
+        },
+    };
+}
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {
+            ok: false,
+            status: 'unavailable',
+            error: {
+                code: 'lsp_no_response',
+                message: 'LSP returned no diagnostics response.',
+            },
+        };
+}
+function unavailableDiagnostics(raw) {
+    const error = raw.error && typeof raw.error === 'object' ? raw.error : {};
+    return {
+        ok: false,
+        status: 'unavailable',
+        diagnostics: [],
+        error: {
+            code: String(error.code ?? 'lsp_unavailable'),
+            message: String(error.message ?? 'Diagnostics are unavailable.'),
+        },
+    };
+}
+function normalizeDiagnosticRecord(value) {
+    const record = value && typeof value === 'object' ? value : {};
+    const severity = String(record.severity ?? 'information');
+    return {
+        file: typeof record.file === 'string' ? record.file : undefined,
+        line: numberOrUndefined(record.line),
+        column: numberOrUndefined(record.column),
+        severity: severity === 'error' || severity === 'warning' || severity === 'hint' ? severity : 'information',
+        code: typeof record.code === 'string' ? record.code : undefined,
+        message: String(record.message ?? ''),
+        source: typeof record.source === 'string' ? record.source : 'cwtools',
+    };
+}
+function asStringArray(value) {
+    return Array.isArray(value) ? value.map(item => String(item)) : [];
+}
+function numberOrUndefined(value) {
+    if (typeof value === 'number')
+        return value;
+    if (typeof value === 'string' && value.trim()) {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : undefined;
+    }
+    return undefined;
+}
+class NodeFilesystemHost {
+    constructor(workspaceRoot, writesEnabled) {
+        this.workspaceRoot = workspaceRoot;
+        this.writesEnabled = writesEnabled;
+    }
+    async readTextFile(filePath) {
+        const resolved = this.resolve(filePath);
+        if (!fssync.existsSync(resolved)) {
+            return { content: '', hasBom: false, exists: false };
+        }
+        const content = await fs.readFile(resolved, 'utf8');
+        return {
+            content,
+            hasBom: content.charCodeAt(0) === 0xfeff,
+            exists: true,
+        };
+    }
+    async writeTextFile(filePath, content) {
+        if (!this.writesEnabled) {
+            throw new Error('writes_disabled');
+        }
+        const resolved = this.resolve(filePath);
+        await fs.mkdir(path.dirname(resolved), { recursive: true });
+        await fs.writeFile(resolved, content, 'utf8');
+    }
+    async list(dirPath) {
+        const resolved = this.resolve(dirPath);
+        const entries = await fs.readdir(resolved, { withFileTypes: true });
+        return entries.map(entry => {
+            const fullPath = path.join(resolved, entry.name);
+            const stat = fssync.existsSync(fullPath) ? fssync.statSync(fullPath) : undefined;
+            return {
+                name: entry.name,
+                type: entry.isDirectory() ? 'directory' : 'file',
+                size: stat?.isFile() ? stat.size : undefined,
+            };
+        });
+    }
+    async glob(pattern, options) {
+        const limit = Math.max(1, Math.min(options?.limit ?? 500, 5000));
+        const suffix = pattern.startsWith('**/*') ? pattern.slice(4) : pattern;
+        const results = [];
+        await walk(this.workspaceRoot, async (filePath) => {
+            if (results.length >= limit)
+                return;
+            if (!suffix || filePath.replace(/\\/g, '/').endsWith(suffix.replace(/\\/g, '/'))) {
+                results.push(path.relative(this.workspaceRoot, filePath).replace(/\\/g, '/'));
+            }
+        });
+        return results;
+    }
+    resolve(filePath) {
+        const resolution = (0, cwtools_shared_1.resolveWorkspacePath)(this.workspaceRoot, filePath);
+        if (!resolution.ok || !resolution.resolvedPath) {
+            throw new Error(`Path '${filePath}' is outside the workspace root.`);
+        }
+        return resolution.resolvedPath;
+    }
+}
+class ThinNodeIndexHost {
+    constructor(workspaceRoot) {
+        this.workspaceRoot = workspaceRoot;
+    }
+    async queryWorkspace(query) {
+        const limit = Math.max(1, Math.min(query.limit ?? 50, 200));
+        const entries = [];
+        await walk(this.workspaceRoot, async (filePath) => {
+            if (entries.length >= limit)
+                return;
+            const rel = path.relative(this.workspaceRoot, filePath).replace(/\\/g, '/');
+            if (!isWorkspaceIndexFile(rel))
+                return;
+            if (query.directory && !rel.toLowerCase().includes(query.directory.toLowerCase()))
+                return;
+            const content = await fs.readFile(filePath, 'utf8').catch(() => '');
+            const lines = content.split(/\r?\n/);
+            for (let index = 0; index < lines.length && entries.length < limit; index++) {
+                const symbol = parseSymbol(lines[index] ?? '', rel);
+                if (!symbol)
+                    continue;
+                if (!matchesName(symbol.name, query.name, query))
+                    continue;
+                if (query.kind && symbol.kind !== query.kind)
+                    continue;
+                if (query.category && symbol.category !== query.category)
+                    continue;
+                if (query.source && symbol.source !== query.source)
+                    continue;
+                entries.push({
+                    ...symbol,
+                    file: rel,
+                    line: index,
+                    origin: 'workspace',
+                    updatedAt: fssync.statSync(filePath).mtimeMs,
+                });
+            }
+        });
+        return {
+            status: 'ready',
+            totalCount: entries.length,
+            entries,
+            indexedSymbolNames: entries.length,
+            indexUpdatedAt: Date.now(),
+            _hint: 'Phase 0 thin Node index only returns lightweight workspace symbols; LSP/index commands remain the Phase 1 source of truth.',
+        };
+    }
+    async queryLocalisation(query) {
+        const limit = Math.max(1, Math.min(query.limit ?? 20, 100));
+        const entries = [];
+        await walk(this.workspaceRoot, async (filePath) => {
+            if (entries.length >= limit)
+                return;
+            const rel = path.relative(this.workspaceRoot, filePath).replace(/\\/g, '/');
+            if (!isLocalisationFile(rel))
+                return;
+            const raw = await fs.readFile(filePath, 'utf8').catch(() => '');
+            const content = raw.charCodeAt(0) === 0xfeff ? raw.slice(1) : raw;
+            const lines = content.split(/\r?\n/);
+            let language = '';
+            for (let index = 0; index < lines.length && entries.length < limit; index++) {
+                const line = lines[index] ?? '';
+                const header = line.match(/^\s*(l_[a-z_]+):/i);
+                if (header?.[1])
+                    language = header[1];
+                const match = line.match(/^\s*([\w.-]+):\d*\s*"([^"]*)"/);
+                if (!match?.[1])
+                    continue;
+                if (query.language && query.language !== language)
+                    continue;
+                if (!matchesLocalisationKey(match[1], query))
+                    continue;
+                entries.push({
+                    key: match[1],
+                    value: match[2] ?? '',
+                    file: rel,
+                    line: index,
+                    language,
+                });
+            }
+        });
+        return {
+            status: 'ready',
+            totalCount: entries.length,
+            entries,
+            indexUpdatedAt: Date.now(),
+            _hint: 'Phase 0 thin Node localisation index scans workspace YML files only.',
+        };
+    }
+}
+async function walk(root, visit) {
+    if (!fssync.existsSync(root))
+        return;
+    const entries = await fs.readdir(root, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+        if (entry.name.startsWith('.') && entry.name !== '.cwtools' && entry.name !== '.cwtools-ai')
+            continue;
+        if (entry.name === 'node_modules' || entry.name === 'dist' || entry.name === 'coverage')
+            continue;
+        const fullPath = path.join(root, entry.name);
+        if (entry.isDirectory()) {
+            await walk(fullPath, visit);
+        }
+        else {
+            await visit(fullPath);
+        }
+    }
+}
+function isWorkspaceIndexFile(relativePath) {
+    return /\.(txt|gfx|asset|gui)$/i.test(relativePath);
+}
+function isLocalisationFile(relativePath) {
+    const normalized = relativePath.toLowerCase();
+    return /\.yml$/.test(normalized)
+        && (normalized.startsWith('localisation/')
+            || normalized.startsWith('localisation_synced/')
+            || normalized.startsWith('localization/'));
+}
+function parseSymbol(line, relativePath) {
+    const namespace = line.match(/^\s*namespace\s*=\s*"?([\w.:-]+)"?/);
+    if (namespace?.[1]) {
+        return { name: namespace[1], kind: 'namespace', source: 'script', category: 'event' };
+    }
+    const id = line.match(/^\s*id\s*=\s*"?([\w.:-]+)"?/);
+    if (id?.[1]) {
+        return { name: id[1], kind: 'event', source: 'script', category: 'event' };
+    }
+    const topLevel = line.match(/^([@\w][\w.:-]*)\s*=/);
+    if (topLevel?.[1]) {
+        const source = relativePath.endsWith('.gui') ? 'gui' : relativePath.endsWith('.gfx') || relativePath.endsWith('.asset') ? 'asset' : 'script';
+        return { name: topLevel[1], kind: 'symbol', source, category: source === 'script' ? 'script' : source };
+    }
+    const sprite = line.match(/\bname\s*=\s*"?(GFX_[\w.:-]+)"?/);
+    if (sprite?.[1]) {
+        return { name: sprite[1], kind: 'sprite', source: 'asset', category: 'asset' };
+    }
+    return null;
+}
+function matchesName(name, queryName, query) {
+    if (!queryName)
+        return true;
+    const needle = queryName.toLowerCase();
+    const haystack = name.toLowerCase();
+    if (query.exact)
+        return haystack === needle;
+    if (query.prefix)
+        return haystack.startsWith(needle);
+    return haystack.includes(needle);
+}
+function matchesLocalisationKey(key, query) {
+    if (!query.key)
+        return true;
+    const haystack = query.caseSensitive ? key : key.toLowerCase();
+    const needle = query.caseSensitive ? query.key : query.key.toLowerCase();
+    if (query.prefix)
+        return haystack.startsWith(needle);
+    if (query.contains)
+        return haystack.includes(needle);
+    return haystack === needle || haystack.includes(needle);
+}

package/dist/hosts/projectDetect.d.ts

@@ -0,0 +1,7 @@
+export interface ProjectSupport {
+    supported: boolean;
+    reason: string;
+    markers: string[];
+    matchedAt?: string;
+}
+export declare function detectProjectSupport(workspaceRoot: string): ProjectSupport;

package/dist/hosts/projectDetect.js

@@ -0,0 +1,151 @@
+"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.detectProjectSupport = detectProjectSupport;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// Strong, unambiguous "this directory is a mod root" signals.
+const ROOT_FILE_MARKERS = ['descriptor.mod'];
+const ROOT_NESTED_FILE_MARKERS = [path.join('.metadata', 'metadata.json')];
+const ROOT_DIR_MARKERS = ['.cwtools', '.cwtools-ai'];
+// PDX content dirs — specific enough at a mod root, but too generic to trust in a
+// far-off ancestor. Generic graphics dirs (gfx/, interface/) are excluded.
+const CONTENT_DIR_MARKERS = ['common', 'events', 'localisation', 'localization'];
+const MAX_ANCESTORS = 6; // how far up to look for a mod root above the cwd
+const MAX_CHILDREN = 64; // how many immediate subdirs to probe when cwd is a parent
+function isFile(p) {
+    try {
+        return fs.statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function isDir(p) {
+    try {
+        return fs.statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+// Markers present directly in `dir`. `includeContent` adds the PDX content dirs,
+// which we only trust at the workspace root / immediate children, not ancestors.
+function markersAt(dir, includeContent) {
+    const found = [];
+    for (const f of ROOT_FILE_MARKERS) {
+        if (isFile(path.join(dir, f)))
+            found.push(f);
+    }
+    for (const f of ROOT_NESTED_FILE_MARKERS) {
+        if (isFile(path.join(dir, f)))
+            found.push(f.replace(/\\/g, '/'));
+    }
+    for (const d of ROOT_DIR_MARKERS) {
+        if (isDir(path.join(dir, d)))
+            found.push(`${d}/`);
+    }
+    if (includeContent) {
+        for (const d of CONTENT_DIR_MARKERS) {
+            if (isDir(path.join(dir, d)))
+                found.push(`${d}/`);
+        }
+    }
+    return found;
+}
+// Decide whether `workspaceRoot` is (or contains, or sits inside) a Paradox mod the
+// CWTools tools can serve. Cheap synchronous stat checks only — run once at startup
+// before anything heavy (the language server) is spawned. Codex usually launches
+// the MCP without --workspace, so the cwd may be the mod root, an ancestor, or a
+// parent holding the mod in a subfolder; all three are accepted.
+function detectProjectSupport(workspaceRoot) {
+    // 1. The workspace root itself (the common, correct case).
+    const atRoot = markersAt(workspaceRoot, true);
+    if (atRoot.length > 0) {
+        return {
+            supported: true,
+            markers: atRoot,
+            matchedAt: workspaceRoot,
+            reason: `Detected Paradox mod markers at the workspace root: ${atRoot.join(', ')}.`,
+        };
+    }
+    // 2. An ancestor mod root (cwd is a subfolder of the mod). Strong markers only.
+    let dir = workspaceRoot;
+    for (let i = 0; i < MAX_ANCESTORS; i++) {
+        const parent = path.dirname(dir);
+        if (!parent || parent === dir)
+            break;
+        dir = parent;
+        const atAncestor = markersAt(dir, false);
+        if (atAncestor.length > 0) {
+            return {
+                supported: true,
+                markers: atAncestor,
+                matchedAt: dir,
+                reason: `Detected a Paradox mod root above the workspace (${dir}): ${atAncestor.join(', ')}.`,
+            };
+        }
+    }
+    // 3. An immediate child that is a mod root (cwd is a parent holding the mod).
+    let children = [];
+    try {
+        children = fs.readdirSync(workspaceRoot, { withFileTypes: true });
+    }
+    catch {
+        children = [];
+    }
+    let probed = 0;
+    for (const child of children) {
+        if (!child.isDirectory() || child.name === 'node_modules')
+            continue;
+        if (probed++ >= MAX_CHILDREN)
+            break;
+        const childDir = path.join(workspaceRoot, child.name);
+        const atChild = markersAt(childDir, true);
+        if (atChild.length > 0) {
+            return {
+                supported: true,
+                markers: atChild.map(m => `${child.name}/${m}`),
+                matchedAt: childDir,
+                reason: `Detected a Paradox mod in a subfolder (${child.name}/): ${atChild.join(', ')}.`,
+            };
+        }
+    }
+    return {
+        supported: false,
+        markers: [],
+        reason: `No Paradox mod markers (descriptor.mod, common/, events/, localisation/, .cwtools/) at, above, or directly under '${workspaceRoot}'.`,
+    };
+}

package/dist/hosts/projectSettings.d.ts

@@ -0,0 +1,11 @@
+import type { DiagnosticsQueryResult } from 'cwtools-shared';
+export declare function getExtensionSetting(workspaceRoot: string, subKey: string): unknown;
+export declare function readIgnoredDiagnostics(workspaceRoot: string): string[];
+export interface LocalisationConfig {
+    languages: string[];
+    source: 'settings' | 'detected' | 'default';
+}
+export declare function resolveLocalisationLanguages(workspaceRoot: string): LocalisationConfig;
+export declare function resolveGeneratedStrings(workspaceRoot: string): string;
+export declare function resolveExperimental(workspaceRoot: string): boolean;
+export declare function applyDiagnosticIgnoreList(result: DiagnosticsQueryResult, ignored: readonly string[]): DiagnosticsQueryResult;