flowseeker 0.1.7

package/dist/pipeline/universalScan.js

@@ -0,0 +1,216 @@
+"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.universalScan = universalScan;
+const path = __importStar(require("path"));
+const vscode = __importStar(require("vscode"));
+const text_1 = require("../utils/text");
+const fileScanner_1 = require("./fileScanner");
+const nodeScan_1 = require("./nodeScan");
+async function universalScan(profile, config, options = {}) {
+    const folders = vscode.workspace.workspaceFolders;
+    if (!folders || folders.length === 0) {
+        return emptyScanStats(config);
+    }
+    if (config.index.enableWorkspaceIndex && folders[0].uri.scheme === "file") {
+        try {
+            return await (0, nodeScan_1.nodeScanWorkspace)(folders[0].uri.fsPath, profile, config, {
+                onProgress: (message) => options.progress?.report({ message }),
+                shouldCancel: () => Boolean(options.token?.isCancellationRequested)
+            });
+        }
+        catch {
+            options.progress?.report({ message: "Workspace index failed; falling back to VSCode scan." });
+        }
+    }
+    const startedAt = Date.now();
+    const maxBytes = config.pipeline.maxTotalBytesMb * 1024 * 1024;
+    const maxRawEvidence = Math.max(config.pipeline.maxCandidates, config.pipeline.maxRawEvidence);
+    let stopReason;
+    const excludeGlob = (0, text_1.toExcludeGlob)(config.project.exclude);
+    const seen = new Set();
+    const uris = [];
+    for (const include of config.project.include) {
+        if (options.token?.isCancellationRequested) {
+            stopReason = "cancelled";
+            break;
+        }
+        const found = await vscode.workspace.findFiles((0, text_1.toWorkspaceGlob)(include), excludeGlob, 5000);
+        for (const uri of found) {
+            const key = uri.toString();
+            if (!seen.has(key)) {
+                seen.add(key);
+                uris.push(uri);
+            }
+            if (uris.length >= config.pipeline.maxFiles) {
+                stopReason = `maxFiles ${config.pipeline.maxFiles} reached during discovery`;
+                break;
+            }
+        }
+        if (stopReason) {
+            break;
+        }
+    }
+    if (uris.length === 0 && !stopReason) {
+        const found = await vscode.workspace.findFiles("**/*", excludeGlob, 5000);
+        uris.push(...found);
+    }
+    const allUnits = [];
+    let scannedFiles = 0;
+    let skippedFiles = 0;
+    let scannedBytes = 0;
+    let scannedTokens = 0;
+    for (const uri of uris) {
+        const processedFiles = scannedFiles + skippedFiles;
+        if (options.token?.isCancellationRequested) {
+            stopReason = "cancelled";
+            break;
+        }
+        if (Date.now() - startedAt > config.pipeline.maxScanMs) {
+            stopReason = `maxScanMs ${config.pipeline.maxScanMs} reached`;
+            break;
+        }
+        if (scannedBytes >= maxBytes) {
+            stopReason = `maxTotalBytesMb ${config.pipeline.maxTotalBytesMb} reached`;
+            break;
+        }
+        if (allUnits.length >= maxRawEvidence) {
+            stopReason = `maxRawEvidence ${maxRawEvidence} reached`;
+            break;
+        }
+        if (processedFiles % 15 === 0) {
+            options.progress?.report({ message: `Scanning ${processedFiles + 1}/${uris.length}: ${formatProgressPath(path.posix.relative(folders[0].uri.path, uri.path))}` });
+        }
+        const fileStartedAt = Date.now();
+        const result = await scanFile(uri, folders[0].uri, profile, config);
+        const fileDurationMs = Date.now() - fileStartedAt;
+        if (result.scanned) {
+            scannedFiles += 1;
+            scannedBytes += result.size;
+            scannedTokens += result.tokenCount;
+        }
+        else {
+            skippedFiles += 1;
+        }
+        allUnits.push(...result.units);
+        if (fileDurationMs > 1000) {
+            options.progress?.report({ message: `Slow scan ${fileDurationMs}ms: ${formatProgressPath(path.posix.relative(folders[0].uri.path, uri.path))} (${result.units.length} evidence)` });
+        }
+        if ((scannedFiles + skippedFiles) % 15 === 0) {
+            options.progress?.report({ message: `Scanned ${scannedFiles}/${uris.length} files, ${allUnits.length} evidence` });
+        }
+        if (allUnits.length >= maxRawEvidence) {
+            stopReason = `maxRawEvidence ${maxRawEvidence} reached`;
+            break;
+        }
+        if ((scannedFiles + skippedFiles) % 25 === 0) {
+            await yieldToHost();
+        }
+    }
+    return {
+        units: allUnits,
+        stats: {
+            scannedFiles,
+            skippedFiles,
+            discoveredFiles: uris.length,
+            scannedBytes,
+            scannedTokens,
+            rawEvidenceCount: allUnits.length,
+            rankedEvidenceCount: allUnits.length,
+            maxCandidates: config.pipeline.maxCandidates,
+            capped: allUnits.length > config.pipeline.maxCandidates,
+            stoppedEarly: Boolean(stopReason),
+            stopReason
+        }
+    };
+}
+async function scanFile(uri, rootUri, profile, config) {
+    const relativePath = path.posix.relative(rootUri.path, uri.path);
+    if (!(0, text_1.isLikelyTextPath)(relativePath)) {
+        return { units: [], scanned: false, size: 0, tokenCount: 0 };
+    }
+    const stat = await vscode.workspace.fs.stat(uri);
+    if (stat.size > config.project.maxFileSizeKb * 1024) {
+        return { units: [], scanned: false, size: stat.size, tokenCount: 0 };
+    }
+    let content;
+    try {
+        const bytes = await vscode.workspace.fs.readFile(uri);
+        content = new TextDecoder("utf-8", { fatal: false }).decode(bytes);
+    }
+    catch {
+        return { units: [], scanned: false, size: stat.size, tokenCount: 0 };
+    }
+    if (content.includes("\u0000")) {
+        return { units: [], scanned: false, size: stat.size, tokenCount: 0 };
+    }
+    return {
+        units: (0, fileScanner_1.scanTextFile)({
+            file: uri.fsPath,
+            relativePath,
+            content,
+            size: stat.size,
+            profile,
+            config
+        }),
+        scanned: true,
+        size: stat.size,
+        tokenCount: (0, text_1.fastTokenEstimate)(`${relativePath}\n${content}`)
+    };
+}
+function emptyScanStats(config) {
+    return {
+        units: [],
+        stats: {
+            scannedFiles: 0,
+            skippedFiles: 0,
+            discoveredFiles: 0,
+            scannedBytes: 0,
+            scannedTokens: 0,
+            rawEvidenceCount: 0,
+            rankedEvidenceCount: 0,
+            maxCandidates: config.pipeline.maxCandidates,
+            capped: false,
+            stoppedEarly: false
+        }
+    };
+}
+function formatProgressPath(relativePath) {
+    return relativePath.length > 120 ? `...${relativePath.slice(-117)}` : relativePath;
+}
+function yieldToHost() {
+    return new Promise((resolve) => setTimeout(resolve, 0));
+}
+//# sourceMappingURL=universalScan.js.map

package/dist/pipeline/verifyAfterApply.js

@@ -0,0 +1,233 @@
+"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.detectCommands = detectCommands;
+exports.runVerification = runVerification;
+exports.verifyAfterEdits = verifyAfterEdits;
+exports.formatVerificationForChat = formatVerificationForChat;
+exports.summarizeVerificationRun = summarizeVerificationRun;
+const cp = __importStar(require("child_process"));
+const path = __importStar(require("path"));
+const vscode = __importStar(require("vscode"));
+const logger_1 = require("../utils/logger");
+async function detectCommands(workspaceRoot, changedFiles) {
+    const commands = [];
+    try {
+        const pkgJsonPath = path.join(workspaceRoot, "package.json");
+        const pkgJson = JSON.parse(await vscode.workspace.fs.readFile(vscode.Uri.file(pkgJsonPath)).then((bytes) => new TextDecoder().decode(bytes)));
+        const scripts = pkgJson.scripts;
+        if (scripts) {
+            if (scripts.test) {
+                commands.push({ label: "npm test", command: "npm", args: ["run", "test", "--", "--passWithNoTests"], cwd: workspaceRoot, kind: "test", scope: "project" });
+            }
+            if (scripts.lint) {
+                commands.push({ label: "npm run lint", command: "npm", args: ["run", "lint"], cwd: workspaceRoot, kind: "lint", scope: "project" });
+            }
+            if (scripts.typecheck || scripts.tsc) {
+                commands.push({ label: "npm run typecheck", command: "npm", args: ["run", scripts.typecheck ? "typecheck" : "tsc"], cwd: workspaceRoot, kind: "typecheck", scope: "project" });
+            }
+        }
+    }
+    catch {
+        // No package.json or unreadable — skip npm commands.
+    }
+    const testFiles = changedFiles.filter((file) => /\.(test|spec)\.(ts|tsx|js|jsx|py|php|java|rb|go|rs)$/.test(file));
+    if (testFiles.length > 0) {
+        for (const testFile of testFiles.slice(0, 5)) {
+            commands.push({
+                label: `Run ${path.basename(testFile)}`,
+                command: "npx",
+                args: ["vitest", "run", testFile, "--passWithNoTests"],
+                cwd: workspaceRoot,
+                kind: "test",
+                scope: "file"
+            });
+        }
+    }
+    return commands;
+}
+async function runVerification(workspaceRoot, changedFiles, commands) {
+    const detected = commands ?? await detectCommands(workspaceRoot, changedFiles);
+    if (detected.length === 0) {
+        return {
+            changedFiles,
+            results: [],
+            summary: "No test, lint, or typecheck commands were detected for this project."
+        };
+    }
+    const results = [];
+    for (const cmd of detected.slice(0, 4)) {
+        const started = Date.now();
+        try {
+            const result = await runCommand(cmd);
+            results.push({ command: cmd, ...result, durationMs: Date.now() - started });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            results.push({
+                command: cmd,
+                exitCode: null,
+                stdout: "",
+                stderr: message,
+                durationMs: Date.now() - started,
+                timedOut: false
+            });
+        }
+    }
+    return {
+        changedFiles,
+        results,
+        summary: renderVerificationSummary(results)
+    };
+}
+function runCommand(cmd) {
+    return new Promise((resolve) => {
+        const child = cp.spawn(cmd.command, cmd.args, {
+            cwd: cmd.cwd,
+            timeout: 60000,
+            shell: true,
+            env: { ...process.env, FORCE_COLOR: "0", CI: "true" }
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString();
+            if (stdout.length > 8000) {
+                stdout = stdout.slice(0, 8000) + "\n... (output truncated)";
+                child.kill();
+            }
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString();
+            if (stderr.length > 4000) {
+                stderr = stderr.slice(0, 4000) + "\n... (output truncated)";
+            }
+        });
+        child.on("close", (code, signal) => {
+            resolve({
+                exitCode: code,
+                stdout: stdout.trim(),
+                stderr: stderr.trim(),
+                timedOut: signal === "SIGTERM" || signal === "SIGKILL"
+            });
+        });
+        child.on("error", (err) => {
+            resolve({
+                exitCode: null,
+                stdout: stdout.trim(),
+                stderr: err.message,
+                timedOut: false
+            });
+        });
+    });
+}
+function renderVerificationSummary(results) {
+    if (results.length === 0) {
+        return "No verification commands were run.";
+    }
+    const lines = ["## Verification Results", ""];
+    let passed = 0;
+    let failed = 0;
+    for (const result of results) {
+        const status = result.exitCode === 0 ? "PASS" : result.timedOut ? "TIMEOUT" : result.exitCode === null ? "ERROR" : "FAIL";
+        if (status === "PASS") {
+            passed += 1;
+        }
+        else if (status === "FAIL" || status === "ERROR") {
+            failed += 1;
+        }
+        lines.push(`### ${status}: ${result.command.label} (${result.durationMs}ms)`, "");
+        if (result.stdout) {
+            const truncated = result.stdout.length > 2000 ? result.stdout.slice(0, 2000) + "\n... (truncated)" : result.stdout;
+            lines.push("```", truncated, "```", "");
+        }
+        if (result.stderr) {
+            lines.push("**Stderr:**", "", "```", result.stderr.slice(0, 1000), "```", "");
+        }
+    }
+    const summaryLine = `${passed} passed, ${failed} failed, ${results.length - passed - failed} other`;
+    lines.unshift(`**Summary:** ${summaryLine}`, "");
+    return lines.join("\n");
+}
+async function verifyAfterEdits(changedFiles) {
+    const folders = vscode.workspace.workspaceFolders;
+    if (!folders?.[0]) {
+        await vscode.window.showWarningMessage("Open a workspace folder before running verification.");
+        return undefined;
+    }
+    const workspaceRoot = folders[0].uri.fsPath;
+    (0, logger_1.logInfo)(`Verification started for ${changedFiles.length} changed file(s).`);
+    try {
+        const run = await runVerification(workspaceRoot, changedFiles);
+        const document = await vscode.workspace.openTextDocument({
+            content: run.summary,
+            language: "markdown"
+        });
+        await vscode.window.showTextDocument(document, { preview: true, viewColumn: vscode.ViewColumn.Beside });
+        const failed = run.results.filter((r) => r.exitCode !== 0 && r.exitCode !== null).length;
+        if (failed > 0) {
+            const action = await vscode.window.showErrorMessage(`${failed} verification check(s) failed. Review the results and fix issues before continuing.`, "Show Results", "Dismiss");
+            if (action === "Show Results") {
+                await vscode.window.showTextDocument(document, { preview: false, viewColumn: vscode.ViewColumn.Beside });
+            }
+        }
+        else if (run.results.length > 0) {
+            await vscode.window.showInformationMessage(`All ${run.results.length} verification check(s) passed.`);
+        }
+        return run;
+    }
+    catch (error) {
+        (0, logger_1.logError)("Verification failed.", error);
+        await vscode.window.showErrorMessage("Verification failed to run. Check the FlowSeeker log for details.");
+        return undefined;
+    }
+}
+function formatVerificationForChat(run) {
+    if (run.results.length === 0) {
+        return "No automated verification was run. Manually check the changed files.";
+    }
+    return renderVerificationSummary(run.results);
+}
+function summarizeVerificationRun(run) {
+    if (run.results.length === 0) {
+        return "Verification complete: no test, lint, build, or typecheck commands were detected for this project.";
+    }
+    const passed = run.results.filter((result) => result.exitCode === 0).length;
+    const failed = run.results.filter((result) => result.exitCode !== 0 && result.exitCode !== null).length;
+    const other = run.results.length - passed - failed;
+    const status = failed > 0 ? "failed" : passed > 0 && other === 0 ? "passed" : "finished";
+    return `Verification ${status}: ${passed} passed, ${failed} failed, ${other} other across ${run.results.length} check(s).`;
+}
+//# sourceMappingURL=verifyAfterApply.js.map

package/dist/runtime/capabilities.js

@@ -0,0 +1,71 @@
+"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.getHostCapabilities = getHostCapabilities;
+exports.summarizeHostCapabilities = summarizeHostCapabilities;
+const vscode = __importStar(require("vscode"));
+function getHostCapabilities(context) {
+    const candidate = vscode;
+    return {
+        appName: vscode.env.appName,
+        version: vscode.version,
+        uriScheme: vscode.env.uriScheme,
+        uiKind: vscode.env.uiKind === vscode.UIKind.Web ? "web" : "desktop",
+        extensionKind: context?.extension.extensionKind === vscode.ExtensionKind.Workspace ? "workspace" : context?.extension.extensionKind === vscode.ExtensionKind.UI ? "ui" : "unknown",
+        hasNativeChat: typeof candidate.chat?.createChatParticipant === "function",
+        hasLanguageModels: typeof candidate.lm?.selectChatModels === "function",
+        hasLanguageModelTools: typeof candidate.lm?.invokeTool === "function",
+        hasMcp: typeof candidate.lm?.registerMcpServerDefinitionProvider === "function",
+        hasLanguageModelProvider: typeof candidate.lm?.registerLanguageModelChatProvider === "function"
+    };
+}
+function summarizeHostCapabilities(capabilities) {
+    return [
+        `Host: ${capabilities.appName} ${capabilities.version}`,
+        `URI scheme: ${capabilities.uriScheme}`,
+        `UI kind: ${capabilities.uiKind}`,
+        `Extension kind: ${capabilities.extensionKind}`,
+        `Sidebar webview: supported`,
+        `Native Chat participant: ${yesNo(capabilities.hasNativeChat)}`,
+        `VS Code Language Model API: ${yesNo(capabilities.hasLanguageModels)}`,
+        `Language Model tools: ${yesNo(capabilities.hasLanguageModelTools)}`,
+        `MCP server provider API: ${yesNo(capabilities.hasMcp)}`,
+        `Language Model provider API: ${yesNo(capabilities.hasLanguageModelProvider)}`
+    ];
+}
+function yesNo(value) {
+    return value ? "supported" : "not available";
+}
+//# sourceMappingURL=capabilities.js.map

package/dist/runtime/hostDetect.js

@@ -0,0 +1,98 @@
+"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.detectHost = detectHost;
+exports.probeLanguageModels = probeLanguageModels;
+exports.summarizeProbe = summarizeProbe;
+const vscode = __importStar(require("vscode"));
+function detectHost() {
+    const appName = vscode.env.appName;
+    const version = vscode.version;
+    const uriScheme = vscode.env.uriScheme;
+    const appNameLower = appName.toLowerCase();
+    if (/windsurf/i.test(appNameLower)) {
+        return { id: "windsurf", appName, version, uriScheme };
+    }
+    if (/cursor/i.test(appNameLower)) {
+        return { id: "cursor", appName, version, uriScheme };
+    }
+    if (/antigravity/i.test(appNameLower)) {
+        return { id: "antigravity", appName, version, uriScheme };
+    }
+    if (/vscodium/i.test(appNameLower)) {
+        return { id: "vscodium", appName, version, uriScheme };
+    }
+    if (/theia/i.test(appNameLower)) {
+        return { id: "theia", appName, version, uriScheme };
+    }
+    if (/insiders?/i.test(appNameLower)) {
+        return { id: "vscode-insiders", appName, version, uriScheme };
+    }
+    if (/visual studio code/i.test(appNameLower) || /code/i.test(appNameLower) || uriScheme === "vscode") {
+        return { id: "vscode", appName, version, uriScheme };
+    }
+    return { id: "unknown", appName, version, uriScheme };
+}
+async function probeLanguageModels(capabilities) {
+    const apiExists = capabilities.hasLanguageModels;
+    if (!apiExists) {
+        return { apiExists: false, apiWorking: false, modelCount: 0, modelVendors: [] };
+    }
+    try {
+        const models = await vscode.lm.selectChatModels({});
+        const modelList = Array.isArray(models) ? models : [];
+        return {
+            apiExists: true,
+            apiWorking: modelList.length > 0,
+            modelCount: modelList.length,
+            modelVendors: [...new Set(modelList.map((m) => m.vendor).filter(Boolean))]
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { apiExists: true, apiWorking: false, modelCount: 0, modelVendors: [], error: message };
+    }
+}
+function summarizeProbe(host, capabilities, probe) {
+    return [
+        `Host detected: ${host.id} (appName: "${host.appName}", version: ${host.version}, scheme: ${host.uriScheme})`,
+        `chatParticipant API: ${capabilities.hasNativeChat ? "exists" : "missing"}`,
+        `Language Model API: ${capabilities.hasLanguageModels ? "exists" : "missing"}`,
+        `  → selectChatModels probe: ${probe.apiWorking ? `${probe.modelCount} model(s), vendors: ${probe.modelVendors.join(", ") || "none"}` : probe.apiExists ? `API exists but returned 0 models${probe.error ? ` (${probe.error})` : ""}` : "N/A"}`,
+        `MCP provider API: ${capabilities.hasMcp ? "exists" : "missing"}`,
+        `Language Model provider API: ${capabilities.hasLanguageModelProvider ? "exists" : "missing"}`
+    ];
+}
+//# sourceMappingURL=hostDetect.js.map

package/dist/runtime/hostTier.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHostTier = getHostTier;
+exports.clearTierCache = clearTierCache;
+exports.tierLabel = tierLabel;
+exports.tierDescription = tierDescription;
+exports.loadHostVerifications = loadHostVerifications;
+exports.saveHostVerification = saveHostVerification;
+exports.getVerificationForHost = getVerificationForHost;
+const hostDetect_1 = require("./hostDetect");
+const capabilities_1 = require("./capabilities");
+const KNOWN_NATIVE_HOSTS = new Set(["vscode", "vscode-insiders"]);
+let cachedTier;
+function getHostTier() {
+    if (cachedTier)
+        return cachedTier;
+    const host = (0, hostDetect_1.detectHost)();
+    const capabilities = (0, capabilities_1.getHostCapabilities)();
+    let tier;
+    let reason;
+    if (!capabilities.hasNativeChat) {
+        tier = "sidebar-primary";
+        reason = `Host "${host.appName}" does not expose the VS Code Chat API. Sidebar chat is the primary interface.`;
+    }
+    else if (KNOWN_NATIVE_HOSTS.has(host.id)) {
+        tier = "native-full";
+        reason = `Host "${host.appName}" is a verified VS Code family editor with full Native Chat support.`;
+    }
+    else {
+        tier = "native-unverified";
+        reason = `Host "${host.appName}" exposes the Chat API but has not been verified to render @flowseeker. Native chat participant is registered; sidebar is the guaranteed interface.`;
+    }
+    cachedTier = { tier, host, capabilities, reason };
+    return cachedTier;
+}
+function clearTierCache() {
+    cachedTier = undefined;
+}
+function tierLabel(tier) {
+    switch (tier) {
+        case "native-full": return "Native Chat";
+        case "native-unverified": return "Native Chat (unverified)";
+        case "sidebar-primary": return "Sidebar";
+    }
+}
+function tierDescription(tier) {
+    switch (tier) {
+        case "native-full":
+            return "@flowseeker /guide works in native chat. Sidebar is also available.";
+        case "native-unverified":
+            return "Native chat may work. Sidebar chat is the guaranteed interface.";
+        case "sidebar-primary":
+            return "Native chat is unavailable. Use the sidebar or Copy Agent Prompt.";
+    }
+}
+const VERIFICATION_KEY = "flowseeker.hostVerifications";
+function loadHostVerifications(context) {
+    return context.globalState.get(VERIFICATION_KEY) ?? [];
+}
+function saveHostVerification(context, verification) {
+    const verifications = loadHostVerifications(context).filter((v) => !(v.hostId === verification.hostId && v.hostVersion === verification.hostVersion));
+    verifications.push(verification);
+    void context.globalState.update(VERIFICATION_KEY, verifications);
+}
+function getVerificationForHost(context, hostId, hostVersion) {
+    return loadHostVerifications(context).find((v) => v.hostId === hostId && v.hostVersion === hostVersion);
+}
+//# sourceMappingURL=hostTier.js.map