@roarpeng/graphflow 0.6.5

package/dist/surfaces/cli/runtime.js

@@ -0,0 +1,1130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installMcpToDetectedAgents = exports.formatModelConfigGuide = exports.detectInstalledAgents = exports.buildMcpServerNode = exports.resolveConfigPath = exports.resolveConfig = exports.resolveGlobalConfigPath = exports.ensureWorkspaceGraphFlowConfig = exports.ensureGlobalGraphFlowConfig = exports.getDefaultConfig = void 0;
+exports.prepareSemanticEnrichmentRuntime = prepareSemanticEnrichmentRuntime;
+exports.applyEnrichmentProviderEnv = applyEnrichmentProviderEnv;
+exports.applyOpenBmbRuntimeEnv = applyOpenBmbRuntimeEnv;
+exports.getGraphFlowSettings = getGraphFlowSettings;
+exports.saveGraphFlowSettings = saveGraphFlowSettings;
+exports.previewContext = previewContext;
+exports.indexGraph = indexGraph;
+exports.rebuildGraph = rebuildGraph;
+exports.enrichSemanticsSilent = enrichSemanticsSilent;
+exports.downloadOpenBmbModel = downloadOpenBmbModel;
+exports.inspectGraph = inspectGraph;
+exports.getSkillInsights = getSkillInsights;
+exports.runTaskResult = runTaskResult;
+exports.runTask = runTask;
+exports.diagnoseRoutingResult = diagnoseRoutingResult;
+exports.diagnoseRouting = diagnoseRouting;
+exports.getSettingsPanelStatus = getSettingsPanelStatus;
+exports.runLearningNightlyResult = runLearningNightlyResult;
+exports.runLearningNightly = runLearningNightly;
+exports.planAndBrainstormResult = planAndBrainstormResult;
+exports.planAndBrainstorm = planAndBrainstorm;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_crypto_1 = require("node:crypto");
+const node_os_1 = require("node:os");
+const brainstormer_1 = require("../../agents/brainstormer");
+const planner_1 = require("../../agents/planner");
+const loader_1 = require("../../config/loader");
+const secrets_1 = require("../../config/secrets");
+const merge_1 = require("../../config/merge");
+const resolve_1 = require("../../config/resolve");
+const embedding_factory_1 = require("../../config/embedding-factory");
+const paths_1 = require("../../config/paths");
+const triage_1 = require("../../core/triage");
+const orchestrator_1 = require("../../core/orchestrator");
+const client_factory_1 = require("../../graph/client-factory");
+const semantic_enricher_1 = require("../../graph/semantic-enricher");
+const sqlite_client_1 = require("../../graph/sqlite-client");
+const file_indexer_1 = require("../../graph/file-indexer");
+const context_slicer_1 = require("../../graph/context-slicer");
+const nightly_trainer_1 = require("../../learning/nightly-trainer");
+const learning_events_1 = require("../../learning/learning-events");
+const model_router_1 = require("../../routing/model-router");
+const provider_health_1 = require("../../routing/provider-health");
+const file_lock_1 = require("../../utils/file-lock");
+const logger_1 = require("../../utils/logger");
+var defaults_1 = require("../../config/defaults");
+Object.defineProperty(exports, "getDefaultConfig", { enumerable: true, get: function () { return defaults_1.getDefaultConfig; } });
+var scaffold_1 = require("../../config/scaffold");
+Object.defineProperty(exports, "ensureGlobalGraphFlowConfig", { enumerable: true, get: function () { return scaffold_1.ensureGlobalGraphFlowConfig; } });
+Object.defineProperty(exports, "ensureWorkspaceGraphFlowConfig", { enumerable: true, get: function () { return scaffold_1.ensureWorkspaceGraphFlowConfig; } });
+Object.defineProperty(exports, "resolveGlobalConfigPath", { enumerable: true, get: function () { return scaffold_1.resolveGlobalConfigPath; } });
+var resolve_2 = require("../../config/resolve");
+Object.defineProperty(exports, "resolveConfig", { enumerable: true, get: function () { return resolve_2.resolveConfig; } });
+Object.defineProperty(exports, "resolveConfigPath", { enumerable: true, get: function () { return resolve_2.resolveConfigPath; } });
+function buildEmbeddingOptions(config) {
+    const embeddingProvider = (0, embedding_factory_1.createEmbeddingProviderFromConfig)(config);
+    if (!embeddingProvider) {
+        return {};
+    }
+    return {
+        embeddingProvider,
+        enableVectorRecall: true,
+        ...(config.embeddingPolicy?.topK !== undefined ? { vectorTopK: config.embeddingPolicy.topK } : {}),
+        ...(config.embeddingPolicy?.minSimilarity !== undefined
+            ? { vectorMinSimilarity: config.embeddingPolicy.minSimilarity }
+            : {}),
+    };
+}
+function resolveEnrichmentBackend(policy) {
+    if (policy?.backend === "network" || policy?.backend === "local" || policy?.backend === "inherit") {
+        return policy.backend;
+    }
+    if (policy?.provider === "openbmb") {
+        return "local";
+    }
+    if (policy?.model || policy?.provider || policy?.apiKey || policy?.baseUrl) {
+        return "network";
+    }
+    return "inherit";
+}
+/** Apply enrichment-specific cloud credentials over generic provider env (network backend only). */
+function prepareSemanticEnrichmentRuntime(configPath) {
+    if (!configPath) {
+        return;
+    }
+    const config = (0, resolve_1.resolveConfig)(configPath);
+    applyOpenBmbRuntimeEnv(config);
+    applyEnrichmentProviderEnv(config);
+}
+function applyEnrichmentProviderEnv(config) {
+    const policy = config.graphPolicy.semanticEnrichment;
+    const backend = resolveEnrichmentBackend(policy);
+    if (backend === "local") {
+        return;
+    }
+    const providerName = (policy?.provider ?? config.tiers.economy.provider).toUpperCase();
+    const providerCfg = config.providers[providerName.toLowerCase()] ?? {};
+    const apiKey = (0, secrets_1.resolveConfigSecret)(policy?.apiKey) ?? (0, secrets_1.resolveConfigSecret)(providerCfg.apiKey);
+    const baseUrl = policy?.baseUrl ?? providerCfg.baseUrl;
+    if (apiKey) {
+        process.env[`${providerName}_API_KEY`] = apiKey;
+    }
+    if (baseUrl) {
+        process.env[`${providerName}_BASE_URL`] = baseUrl;
+    }
+}
+function applyOpenBmbRuntimeEnv(config) {
+    const genericProviders = ["openai", "anthropic", "bailian", "doubao"];
+    for (const name of genericProviders) {
+        const cfg = config.providers[name];
+        if (!cfg) {
+            continue;
+        }
+        const envPrefix = name.toUpperCase();
+        const apiKey = (0, secrets_1.resolveConfigSecret)(cfg.apiKey);
+        if (apiKey) {
+            process.env[`${envPrefix}_API_KEY`] = apiKey;
+        }
+        if (cfg.baseUrl) {
+            process.env[`${envPrefix}_BASE_URL`] = cfg.baseUrl;
+        }
+    }
+    const openbmb = config.providers.openbmb;
+    if (!openbmb) {
+        return;
+    }
+    if (openbmb.mode) {
+        process.env.GRAPHFLOW_OPENBMB_MODE = openbmb.mode;
+    }
+    if (openbmb.baseUrl) {
+        process.env.GRAPHFLOW_OPENBMB_BASE_URL = openbmb.baseUrl;
+    }
+    const openbmbApiKey = (0, secrets_1.resolveConfigSecret)(openbmb.apiKey);
+    if (openbmbApiKey) {
+        process.env.GRAPHFLOW_OPENBMB_API_KEY = openbmbApiKey;
+    }
+    const modelPath = (0, secrets_1.resolveConfigSecret)(openbmb.modelPath);
+    if (modelPath) {
+        process.env.GRAPHFLOW_OPENBMB_MODEL_PATH = modelPath;
+    }
+    const commandPath = (0, secrets_1.resolveConfigSecret)(openbmb.commandPath);
+    if (commandPath) {
+        process.env.GRAPHFLOW_MINICPM_COMMAND = commandPath;
+    }
+    if (openbmb.modelUrl) {
+        process.env.GRAPHFLOW_MINICPM_MODEL_URL = openbmb.modelUrl;
+    }
+    if (openbmb.modelSha256) {
+        process.env.GRAPHFLOW_MINICPM_MODEL_SHA256 = openbmb.modelSha256;
+    }
+    if (openbmb.autoDownloadModel !== undefined) {
+        process.env.GRAPHFLOW_OPENBMB_AUTO_DOWNLOAD = openbmb.autoDownloadModel ? "1" : "0";
+    }
+    if (openbmb.engine) {
+        process.env.GRAPHFLOW_MINICPM_ENGINE = openbmb.engine;
+    }
+    if (openbmb.timeoutMs !== undefined) {
+        process.env.GRAPHFLOW_OPENBMB_TIMEOUT_MS = String(openbmb.timeoutMs);
+    }
+    if (openbmb.maxTokens !== undefined) {
+        process.env.GRAPHFLOW_OPENBMB_MAX_TOKENS = String(openbmb.maxTokens);
+    }
+    if (openbmb.temperature !== undefined) {
+        process.env.GRAPHFLOW_OPENBMB_TEMPERATURE = String(openbmb.temperature);
+    }
+    const evolution = config.learningPolicy.skillEvolution;
+    if (evolution?.model) {
+        process.env.GRAPHFLOW_SKILL_EVOLVE_MODEL = evolution.model;
+    }
+    if (evolution?.minCoOccur !== undefined) {
+        process.env.GRAPHFLOW_SKILL_EVOLVE_MIN_COOCCUR = String(evolution.minCoOccur);
+    }
+    if (evolution?.minSuccess !== undefined) {
+        process.env.GRAPHFLOW_SKILL_EVOLVE_MIN_SUCCESS = String(evolution.minSuccess);
+    }
+    process.env.GRAPHFLOW_SKILL_TRIPLE_FUSION = evolution?.enableTripleFusion === false ? "0" : "1";
+}
+function getGraphFlowSettings(configPath = "graphflow.config.json") {
+    const actualPath = (0, resolve_1.resolveConfigPath)(configPath);
+    const config = (0, resolve_1.resolveConfig)(actualPath);
+    const provider = config.tiers.smart.provider;
+    const rawConfig = readRawConfig(actualPath);
+    const providerConfig = config.providers[provider] ?? {};
+    const rawProviderConfig = rawConfig?.providers?.[provider] ?? {};
+    const rawOpenBmbConfig = rawConfig?.providers?.openbmb ?? {};
+    const openbmbConfig = config.providers.openbmb ?? {};
+    const apiKeyEnvVar = (0, secrets_1.formatApiKeyForSettings)(rawProviderConfig.apiKey ?? providerConfig.apiKey);
+    const openbmbModelUrl = rawOpenBmbConfig.modelUrl ?? openbmbConfig.modelUrl ?? process.env.GRAPHFLOW_MINICPM_MODEL_URL;
+    const openbmbModelSha256 = rawOpenBmbConfig.modelSha256 ?? openbmbConfig.modelSha256 ?? process.env.GRAPHFLOW_MINICPM_MODEL_SHA256;
+    const openbmbAutoDownloadRaw = rawOpenBmbConfig.autoDownloadModel ?? openbmbConfig.autoDownloadModel;
+    const openbmbAutoDownload = typeof openbmbAutoDownloadRaw === "boolean"
+        ? openbmbAutoDownloadRaw
+        : String(process.env.GRAPHFLOW_OPENBMB_AUTO_DOWNLOAD ?? "0") === "1";
+    return {
+        configPath: actualPath,
+        provider,
+        smartModel: config.tiers.smart.model ?? "",
+        economyModel: config.tiers.economy.model ?? "",
+        ...(apiKeyEnvVar ? { apiKeyEnvVar } : {}),
+        ...(rawProviderConfig.baseUrl || providerConfig.baseUrl
+            ? { baseUrl: rawProviderConfig.baseUrl ?? providerConfig.baseUrl }
+            : {}),
+        maxContextTokens: config.graphPolicy.maxContextTokens,
+        layerQuota: config.graphPolicy.layerQuota ?? { l1: 6, l2: 4, l3: 3 },
+        enableNearLosslessMode: config.graphPolicy.enableNearLosslessMode ?? false,
+        autoIndexOnPreview: config.graphPolicy.autoIndexOnPreview ?? true,
+        autoIndexOnRun: config.graphPolicy.autoIndexOnRun ?? true,
+        autoIndexOnSave: config.graphPolicy.autoIndexOnSave ?? false,
+        transport: config.graphPolicy.transport,
+        graphStorePath: config.graphPolicy.graphStorePath ?? "tmp/graphflow-graph.json",
+        enrichmentBackend: resolveEnrichmentBackend(config.graphPolicy.semanticEnrichment),
+        enrichmentProvider: config.graphPolicy.semanticEnrichment?.provider ?? "",
+        enrichmentModel: config.graphPolicy.semanticEnrichment?.model ?? "",
+        ...(() => {
+            const enrichPolicy = config.graphPolicy.semanticEnrichment;
+            const enrichProvider = enrichPolicy?.provider ?? config.tiers.economy.provider;
+            const rawEnrichPolicy = rawConfig?.graphPolicy?.semanticEnrichment ?? {};
+            const rawEnrichProvider = rawConfig?.providers?.[enrichProvider] ?? {};
+            const apiKey = (0, secrets_1.formatApiKeyForSettings)(rawEnrichPolicy.apiKey ?? rawEnrichProvider.apiKey);
+            const baseUrl = rawEnrichPolicy.baseUrl ?? rawEnrichProvider.baseUrl;
+            return {
+                ...(apiKey ? { enrichmentApiKey: apiKey } : {}),
+                ...(typeof baseUrl === "string" && baseUrl.trim() ? { enrichmentBaseUrl: baseUrl.trim() } : {}),
+            };
+        })(),
+        openbmbMode: (openbmbConfig.mode ?? "embedded"),
+        openbmbEngine: (openbmbConfig.engine ?? "command"),
+        openbmbModel: config.learningPolicy.skillEvolution?.model ??
+            (provider === "openbmb" ? config.tiers.economy.model ?? config.tiers.smart.model ?? "" : ""),
+        ...(rawOpenBmbConfig.baseUrl || openbmbConfig.baseUrl
+            ? { openbmbBaseUrl: rawOpenBmbConfig.baseUrl ?? openbmbConfig.baseUrl }
+            : {}),
+        ...(rawOpenBmbConfig.modelPath || openbmbConfig.modelPath
+            ? { openbmbModelPath: rawOpenBmbConfig.modelPath ?? openbmbConfig.modelPath }
+            : {}),
+        ...(rawOpenBmbConfig.commandPath || openbmbConfig.commandPath
+            ? { openbmbCommandPath: rawOpenBmbConfig.commandPath ?? openbmbConfig.commandPath }
+            : {}),
+        openbmbAutoDownload,
+        ...(typeof openbmbModelUrl === "string" && openbmbModelUrl.trim().length > 0
+            ? { openbmbModelUrl }
+            : {}),
+        ...(typeof openbmbModelSha256 === "string" && openbmbModelSha256.trim().length > 0
+            ? { openbmbModelSha256 }
+            : {}),
+    };
+}
+function saveGraphFlowSettings(settings, configPath = "graphflow.config.json") {
+    const actualPath = (0, resolve_1.resolveConfigPath)(configPath);
+    const current = (0, resolve_1.resolveConfig)(actualPath);
+    const providerConfig = {
+        ...(settings.apiKeyEnvVar?.trim() ? { apiKey: (0, secrets_1.formatApiKeyForConfig)(settings.apiKeyEnvVar) } : {}),
+        ...(settings.baseUrl ? { baseUrl: settings.baseUrl } : {}),
+    };
+    const openbmbProviderConfig = {
+        ...(settings.openbmbBaseUrl ? { baseUrl: settings.openbmbBaseUrl } : {}),
+        ...(settings.openbmbModelPath ? { modelPath: settings.openbmbModelPath } : {}),
+        ...(settings.openbmbCommandPath ? { commandPath: settings.openbmbCommandPath } : {}),
+        ...(settings.openbmbModelUrl ? { modelUrl: settings.openbmbModelUrl } : {}),
+        ...(settings.openbmbModelSha256 ? { modelSha256: settings.openbmbModelSha256 } : {}),
+        mode: settings.openbmbMode,
+        engine: settings.openbmbEngine,
+        autoDownloadModel: settings.openbmbAutoDownload,
+    };
+    const nextSmartModel = settings.provider === "openbmb" ? settings.openbmbModel : settings.smartModel;
+    const nextEconomyModel = settings.provider === "openbmb" ? settings.openbmbModel : settings.economyModel;
+    const updated = (0, loader_1.validateConfig)({
+        ...current,
+        providers: {
+            ...current.providers,
+            [settings.provider]: providerConfig,
+            openbmb: {
+                ...(current.providers.openbmb ?? {}),
+                ...openbmbProviderConfig,
+            },
+        },
+        tiers: {
+            smart: {
+                provider: settings.provider,
+                ...(nextSmartModel?.trim()
+                    ? { model: nextSmartModel.trim() }
+                    : current.tiers.smart.model
+                        ? { model: current.tiers.smart.model }
+                        : {}),
+            },
+            economy: {
+                provider: settings.provider,
+                ...(nextEconomyModel?.trim()
+                    ? { model: nextEconomyModel.trim() }
+                    : current.tiers.economy.model
+                        ? { model: current.tiers.economy.model }
+                        : {}),
+            },
+        },
+        graphPolicy: {
+            ...current.graphPolicy,
+            enableNearLosslessMode: settings.enableNearLosslessMode,
+            autoIndexOnPreview: settings.autoIndexOnPreview,
+            autoIndexOnRun: settings.autoIndexOnRun,
+            autoIndexOnSave: settings.autoIndexOnSave,
+            transport: settings.transport,
+            graphStorePath: settings.graphStorePath,
+            maxContextTokens: Math.max(1, Math.floor(settings.maxContextTokens)),
+            layerQuota: {
+                l1: Math.max(0, Math.floor(settings.layerQuota.l1)),
+                l2: Math.max(0, Math.floor(settings.layerQuota.l2)),
+                l3: Math.max(0, Math.floor(settings.layerQuota.l3)),
+            },
+            semanticEnrichment: {
+                ...(current.graphPolicy.semanticEnrichment ?? {}),
+                backend: settings.enrichmentBackend,
+                ...(settings.enrichmentBackend === "local"
+                    ? { provider: "openbmb" }
+                    : settings.enrichmentProvider?.trim()
+                        ? { provider: settings.enrichmentProvider.trim() }
+                        : settings.enrichmentBackend === "inherit"
+                            ? {}
+                            : current.graphPolicy.semanticEnrichment?.provider
+                                ? { provider: current.graphPolicy.semanticEnrichment.provider }
+                                : {}),
+                ...(settings.enrichmentModel?.trim()
+                    ? { model: settings.enrichmentModel.trim() }
+                    : current.graphPolicy.semanticEnrichment?.model
+                        ? { model: current.graphPolicy.semanticEnrichment.model }
+                        : {}),
+                ...(settings.enrichmentBackend !== "local" && settings.enrichmentApiKey?.trim()
+                    ? { apiKey: (0, secrets_1.formatApiKeyForConfig)(settings.enrichmentApiKey) }
+                    : {}),
+                ...(settings.enrichmentBackend !== "local" && settings.enrichmentBaseUrl?.trim()
+                    ? { baseUrl: settings.enrichmentBaseUrl.trim() }
+                    : {}),
+            },
+        },
+        learningPolicy: {
+            ...current.learningPolicy,
+            skillEvolution: {
+                ...(current.learningPolicy.skillEvolution ?? {}),
+                ...(settings.openbmbModel?.trim() ? { model: settings.openbmbModel.trim() } : {}),
+            },
+        },
+    });
+    if (settings.openbmbModelUrl) {
+        process.env.GRAPHFLOW_MINICPM_MODEL_URL = settings.openbmbModelUrl;
+    }
+    if (settings.openbmbModelSha256) {
+        process.env.GRAPHFLOW_MINICPM_MODEL_SHA256 = settings.openbmbModelSha256;
+    }
+    process.env.GRAPHFLOW_OPENBMB_AUTO_DOWNLOAD = settings.openbmbAutoDownload ? "1" : "0";
+    const dir = (0, node_path_1.dirname)(actualPath);
+    if (dir && dir !== ".") {
+        (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    }
+    (0, node_fs_1.writeFileSync)(actualPath, `${JSON.stringify(updated, null, 2)}\n`, "utf8");
+    return getGraphFlowSettings(actualPath);
+}
+async function previewContext(query, configPath) {
+    const config = (0, resolve_1.resolveConfig)(configPath);
+    applyOpenBmbRuntimeEnv(config);
+    const graphClient = (0, client_factory_1.createGraphClient)(config);
+    if (config.graphPolicy.autoIndexOnPreview) {
+        const indexOptions = config.graphPolicy.includeExtensions
+            ? { includeExtensions: config.graphPolicy.includeExtensions }
+            : undefined;
+        await (0, file_indexer_1.indexWorkspaceFiles)(graphClient, config.graphPolicy.workspaceRoot ?? process.cwd(), {
+            ...indexOptions,
+        });
+    }
+    const packageOptions = {
+        ...(config.graphPolicy.layerQuota ? { layerQuota: config.graphPolicy.layerQuota } : {}),
+        ...buildEmbeddingOptions(config),
+    };
+    const pkg = await (0, context_slicer_1.buildLayeredContextPackage)(graphClient, query, config.graphPolicy.maxContextTokens, packageOptions);
+    const refill = (0, context_slicer_1.createContextRefillManager)(graphClient, config.graphPolicy.maxContextTokens, packageOptions);
+    await refill.initialPackage(query);
+    const refillPreview = await refill.refill([query]);
+    const rawTokenEstimate = estimateRawContextTokens(await resolveGraphStoreAfterIndex(config, graphClient), query, pkg.tokenEstimate);
+    return {
+        query,
+        summaryCount: pkg.summaryChannel.length,
+        anchorCount: pkg.anchorChannel.length,
+        tokenEstimate: pkg.tokenEstimate,
+        truncated: pkg.truncated,
+        anchorsByLayer: {
+            l1: pkg.anchorChannel.filter((item) => item.layer === "L1").length,
+            l2: pkg.anchorChannel.filter((item) => item.layer === "L2").length,
+            l3: pkg.anchorChannel.filter((item) => item.layer === "L3").length,
+        },
+        refillPreview,
+        summary: pkg.summaryChannel,
+        anchors: pkg.anchorChannel,
+        tokenBudget: {
+            maxContextTokens: config.graphPolicy.maxContextTokens,
+            estimatedRawTokens: rawTokenEstimate,
+            compressedTokens: pkg.tokenEstimate,
+            estimatedSavingsPercent: calculateSavingsPercent(rawTokenEstimate, pkg.tokenEstimate),
+            budgetUsedPercent: calculateBudgetUsedPercent(pkg.tokenEstimate, config.graphPolicy.maxContextTokens),
+        },
+    };
+}
+async function indexGraph(rootDir, configPath) {
+    const config = (0, resolve_1.resolveConfig)(configPath);
+    applyOpenBmbRuntimeEnv(config);
+    const graphClient = (0, client_factory_1.createGraphClient)(config);
+    const targetDir = rootDir || config.graphPolicy.workspaceRoot || process.cwd();
+    const indexOptions = config.graphPolicy.includeExtensions
+        ? { includeExtensions: config.graphPolicy.includeExtensions }
+        : undefined;
+    const indexed = await (0, file_indexer_1.indexWorkspaceFiles)(graphClient, targetDir, {
+        ...indexOptions,
+    });
+    await maybeRunSemanticEnrichment(config, graphClient);
+    return indexed;
+}
+async function rebuildGraph(rootDir, configPath) {
+    const config = (0, resolve_1.resolveConfig)(configPath);
+    applyOpenBmbRuntimeEnv(config);
+    const graphClient = (0, client_factory_1.createGraphClient)(config);
+    const targetDir = rootDir || config.graphPolicy.workspaceRoot || process.cwd();
+    const storePath = (0, paths_1.resolveGraphStorePath)(config);
+    (0, file_indexer_1.clearGraphIndexArtifacts)(targetDir, storePath);
+    const indexOptions = config.graphPolicy.includeExtensions
+        ? { includeExtensions: config.graphPolicy.includeExtensions }
+        : undefined;
+    const indexed = await (0, file_indexer_1.indexWorkspaceFiles)(graphClient, targetDir, {
+        ...indexOptions,
+        forceReindex: true,
+    });
+    await maybeRunSemanticEnrichment(config, graphClient);
+    return {
+        ...indexed,
+        cleared: true,
+        storePath,
+    };
+}
+async function maybeRunSemanticEnrichment(config, graphClient) {
+    const enrichPolicy = config.graphPolicy.semanticEnrichment;
+    if (!enrichPolicy?.enabled || !enrichPolicy.autoRunOnIndex || enrichPolicy.mode === "off") {
+        return;
+    }
+    const selection = (0, model_router_1.resolveModelForRole)("enricher");
+    const health = (0, provider_health_1.buildProviderHealthMap)(config);
+    if (!health[selection.provider]) {
+        logger_1.logger.warn(`Skipping semantic enrichment: ${selection.provider} provider is not configured or healthy`);
+        return;
+    }
+    applyEnrichmentProviderEnv(config);
+    try {
+        await (0, semantic_enricher_1.enrichGraphSemanticsSilent)(graphClient, {
+            ...(enrichPolicy.batchSize !== undefined ? { batchSize: enrichPolicy.batchSize } : {}),
+            ...(enrichPolicy.sleepMs !== undefined ? { sleepMs: enrichPolicy.sleepMs } : {}),
+            ...(enrichPolicy.model ? { model: enrichPolicy.model } : {}),
+            ...(enrichPolicy.timeoutMs !== undefined ? { timeoutMs: enrichPolicy.timeoutMs } : {}),
+        });
+    }
+    catch (error) {
+        logger_1.logger.warn({ error }, "Semantic enrichment skipped after provider failure");
+    }
+}
+async function enrichSemanticsSilent(configPath, options) {
+    const config = (0, resolve_1.resolveConfig)(configPath);
+    applyOpenBmbRuntimeEnv(config);
+    applyEnrichmentProviderEnv(config);
+    const graphClient = (0, client_factory_1.createGraphClient)(config);
+    const enrichPolicy = config.graphPolicy.semanticEnrichment;
+    const enricherOptions = {};
+    const batchSize = options?.batchSize ?? enrichPolicy?.batchSize;
+    if (batchSize !== undefined) {
+        enricherOptions.batchSize = batchSize;
+    }
+    const sleepMs = options?.sleepMs ?? enrichPolicy?.sleepMs;
+    if (sleepMs !== undefined) {
+        enricherOptions.sleepMs = sleepMs;
+    }
+    const timeoutMs = options?.timeoutMs ?? enrichPolicy?.timeoutMs;
+    if (timeoutMs !== undefined) {
+        enricherOptions.timeoutMs = timeoutMs;
+    }
+    if (enrichPolicy?.model) {
+        enricherOptions.model = enrichPolicy.model;
+    }
+    return (0, semantic_enricher_1.enrichGraphSemanticsSilent)(graphClient, enricherOptions);
+}
+async function downloadOpenBmbModel(configPath, options) {
+    const config = (0, resolve_1.resolveConfig)(configPath);
+    applyOpenBmbRuntimeEnv(config);
+    const model = options?.model ?? "minicpm5-1b";
+    const defaultUrl = process.env.GRAPHFLOW_MINICPM_MODEL_URL;
+    const url = options?.url ?? defaultUrl;
+    const configuredPath = options?.targetPath ?? config.providers.openbmb?.modelPath;
+    const fallbackPath = (0, node_path_1.join)((0, node_os_1.tmpdir)(), "graphflow-models", `${model}.gguf`);
+    const targetPath = configuredPath ?? fallbackPath;
+    const force = options?.force ?? false;
+    const expectedSha = options?.sha256 ?? process.env.GRAPHFLOW_MINICPM_MODEL_SHA256;
+    const partialPath = `${targetPath}.part`;
+    const lockPath = `${targetPath}.lock`;
+    return (0, file_lock_1.withFileLock)(lockPath, async () => {
+        if ((0, node_fs_1.existsSync)(targetPath) && !force) {
+            const bytes = getFileSize(targetPath);
+            const verified = expectedSha ? (await sha256File(targetPath)) === expectedSha.toLowerCase() : true;
+            options?.onProgress?.({
+                model,
+                targetPath,
+                downloadedBytes: bytes,
+                totalBytes: bytes,
+                resumed: false,
+                percent: 100,
+                stage: "skipped",
+            });
+            return {
+                model,
+                targetPath,
+                bytes,
+                skipped: true,
+                verified,
+            };
+        }
+        if (!url) {
+            throw new Error("Model download URL is required. Set GRAPHFLOW_MINICPM_MODEL_URL or pass --url.");
+        }
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(targetPath), { recursive: true });
+        let partialSize = 0;
+        if ((0, node_fs_1.existsSync)(partialPath) && !force) {
+            try {
+                partialSize = (0, node_fs_1.statSync)(partialPath).size;
+            }
+            catch {
+                partialSize = 0;
+            }
+        }
+        if (force) {
+            (0, node_fs_1.rmSync)(partialPath, { force: true });
+            partialSize = 0;
+        }
+        options?.onProgress?.({
+            model,
+            targetPath,
+            downloadedBytes: partialSize,
+            resumed: partialSize > 0,
+            stage: "starting",
+        });
+        const fetchInit = {};
+        if (partialSize > 0) {
+            fetchInit.headers = { range: `bytes=${partialSize}-` };
+        }
+        const response = await fetch(url, fetchInit);
+        if (!response.ok) {
+            throw new Error(`Model download failed: ${response.status} ${response.statusText}`);
+        }
+        const acceptsRange = response.status === 206;
+        if (!acceptsRange && partialSize > 0) {
+            (0, node_fs_1.rmSync)(partialPath, { force: true });
+            partialSize = 0;
+        }
+        const contentLength = Number(response.headers.get("content-length") ?? "0");
+        const totalBytes = Number.isFinite(contentLength) && contentLength > 0
+            ? partialSize + contentLength
+            : undefined;
+        const stream = response.body;
+        if (!stream) {
+            throw new Error("Model download failed: empty response body");
+        }
+        const reader = stream.getReader();
+        const resumed = partialSize > 0 && acceptsRange;
+        const writer = (0, node_fs_1.createWriteStream)(partialPath, { flags: resumed ? "a" : "w" });
+        let downloadedBytes = partialSize;
+        let lastReportedBytes = -1;
+        const emitProgress = (stage) => {
+            if (downloadedBytes === lastReportedBytes && stage === "downloading") {
+                return;
+            }
+            lastReportedBytes = downloadedBytes;
+            const percent = totalBytes && totalBytes > 0
+                ? Math.min(100, Number(((downloadedBytes / totalBytes) * 100).toFixed(1)))
+                : undefined;
+            options?.onProgress?.({
+                model,
+                targetPath,
+                downloadedBytes,
+                ...(totalBytes ? { totalBytes } : {}),
+                resumed,
+                ...(percent !== undefined ? { percent } : {}),
+                stage,
+            });
+        };
+        emitProgress("downloading");
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            if (value) {
+                const chunk = Buffer.from(value);
+                await new Promise((resolve, reject) => {
+                    writer.write(chunk, (error) => {
+                        if (error) {
+                            reject(error);
+                            return;
+                        }
+                        resolve();
+                    });
+                });
+                downloadedBytes += chunk.length;
+                emitProgress("downloading");
+            }
+        }
+        await new Promise((resolve, reject) => {
+            writer.end((error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve();
+            });
+        });
+        (0, node_fs_1.renameSync)(partialPath, targetPath);
+        if (expectedSha) {
+            options?.onProgress?.({
+                model,
+                targetPath,
+                downloadedBytes,
+                ...(totalBytes ? { totalBytes } : {}),
+                resumed,
+                percent: 100,
+                stage: "verifying",
+            });
+            const actual = await sha256File(targetPath);
+            if (actual !== expectedSha.toLowerCase()) {
+                (0, node_fs_1.rmSync)(targetPath, { force: true });
+                throw new Error(`Model sha256 mismatch. expected=${expectedSha.toLowerCase()} actual=${actual}`);
+            }
+        }
+        const finalBytes = getFileSize(targetPath);
+        options?.onProgress?.({
+            model,
+            targetPath,
+            downloadedBytes: finalBytes,
+            totalBytes: finalBytes,
+            resumed,
+            percent: 100,
+            stage: "completed",
+        });
+        return {
+            model,
+            targetPath,
+            bytes: finalBytes,
+            skipped: false,
+            verified: Boolean(expectedSha),
+            ...(resumed ? { resumed: true } : {}),
+        };
+    });
+}
+async function inspectGraph(configPath, options) {
+    const config = (0, resolve_1.resolveConfig)(configPath);
+    const nodeLimit = Math.max(1, options?.nodeLimit ?? 24);
+    const edgeLimit = Math.max(1, options?.edgeLimit ?? 36);
+    const emptyTypeCount = {
+        File: 0,
+        Symbol: 0,
+        Module: 0,
+        TaskRun: 0,
+        Decision: 0,
+        Skill: 0,
+    };
+    if (config.graphPolicy.transport === "mcp-http") {
+        return {
+            transport: config.graphPolicy.transport,
+            storePath: (0, paths_1.resolveGraphStorePath)(config),
+            nodeCount: 0,
+            edgeCount: 0,
+            nodeTypeCount: emptyTypeCount,
+            topRelations: [],
+            sampleNodes: [],
+            sampleEdges: [],
+        };
+    }
+    let store = loadGraphStore(config);
+    if (store.nodes.length === 0) {
+        const graphClient = (0, client_factory_1.createGraphClient)(config);
+        const indexOptions = config.graphPolicy.includeExtensions
+            ? { includeExtensions: config.graphPolicy.includeExtensions }
+            : undefined;
+        await (0, file_indexer_1.indexWorkspaceFiles)(graphClient, config.graphPolicy.workspaceRoot ?? process.cwd(), {
+            ...indexOptions,
+        });
+        store = await resolveGraphStoreAfterIndex(config, graphClient);
+    }
+    const relationCounts = new Map();
+    for (const edge of store.edges) {
+        relationCounts.set(edge.relation, (relationCounts.get(edge.relation) ?? 0) + 1);
+    }
+    const nodeTypeCount = { ...emptyTypeCount };
+    for (const node of store.nodes) {
+        nodeTypeCount[node.type] += 1;
+    }
+    return {
+        transport: config.graphPolicy.transport,
+        storePath: (0, paths_1.resolveGraphStorePath)(config),
+        nodeCount: store.nodes.length,
+        edgeCount: store.edges.length,
+        nodeTypeCount,
+        topRelations: Array.from(relationCounts.entries())
+            .map(([relation, count]) => ({ relation, count }))
+            .sort((a, b) => b.count - a.count || a.relation.localeCompare(b.relation))
+            .slice(0, 8),
+        ...(() => {
+            const isMetaFile = (id) => {
+                const lower = id.toLowerCase();
+                return lower.includes(".md") || lower.includes(".json") || lower.includes(".yml") || lower.includes(".yaml") || lower.includes(".github") || lower.includes(".claude") || lower.includes(".codex");
+            };
+            const adj = new Map();
+            for (const e of store.edges) {
+                if (!adj.has(e.from))
+                    adj.set(e.from, []);
+                if (!adj.has(e.to))
+                    adj.set(e.to, []);
+                adj.get(e.from).push(e.to);
+                adj.get(e.to).push(e.from);
+            }
+            const nodeMap = new Map(store.nodes.map(n => [n.id, n]));
+            const degree = (id) => adj.get(id)?.length || 0;
+            const sortedCandidates = store.nodes
+                .filter(n => n.type === "File" && !isMetaFile(n.id))
+                .sort((a, b) => degree(b.id) - degree(a.id));
+            if (sortedCandidates.length === 0) {
+                return { sampleNodes: [], sampleEdges: [] };
+            }
+            const visited = new Set();
+            const selected = [];
+            let candidateIndex = 0;
+            while (selected.length < nodeLimit && candidateIndex < sortedCandidates.length) {
+                let root = sortedCandidates[candidateIndex++];
+                while (root && visited.has(root.id) && candidateIndex < sortedCandidates.length) {
+                    root = sortedCandidates[candidateIndex++];
+                }
+                if (!root || visited.has(root.id))
+                    break;
+                const queue = [root.id];
+                while (queue.length > 0 && selected.length < nodeLimit) {
+                    const id = queue.shift();
+                    if (visited.has(id))
+                        continue;
+                    visited.add(id);
+                    const node = nodeMap.get(id);
+                    if (node) {
+                        selected.push(node);
+                        const neighbors = adj.get(id) || [];
+                        queue.push(...neighbors);
+                    }
+                }
+            }
+            const sampleNodeIds = new Set(selected.map(n => n.id));
+            return {
+                sampleNodes: selected.map(node => ({
+                    id: node.id,
+                    type: node.type,
+                    contentPreview: compactPreview(node.content, 96),
+                })),
+                sampleEdges: store.edges
+                    .filter(edge => sampleNodeIds.has(edge.from) && sampleNodeIds.has(edge.to))
+                    .slice(0, edgeLimit)
+                    .map(edge => ({
+                    from: edge.from,
+                    relation: edge.relation,
+                    to: edge.to,
+                }))
+            };
+        })(),
+    };
+}
+async function getSkillInsights(configPath, limit = 12) {
+    const config = (0, resolve_1.resolveConfig)(configPath);
+    const boundedLimit = Math.max(1, limit);
+    if (config.graphPolicy.transport === "mcp-http") {
+        return {
+            source: "unavailable",
+            transport: config.graphPolicy.transport,
+            storePath: (0, paths_1.resolveGraphStorePath)(config),
+            skills: [],
+        };
+    }
+    let store = loadGraphStore(config);
+    if (store.nodes.length === 0) {
+        const graphClient = (0, client_factory_1.createGraphClient)(config);
+        const indexOptions = config.graphPolicy.includeExtensions
+            ? { includeExtensions: config.graphPolicy.includeExtensions }
+            : undefined;
+        await (0, file_indexer_1.indexWorkspaceFiles)(graphClient, config.graphPolicy.workspaceRoot ?? process.cwd(), {
+            ...indexOptions,
+        });
+        store = await resolveGraphStoreAfterIndex(config, graphClient);
+    }
+    const skills = store.nodes
+        .filter((node) => node.type === "Skill")
+        .map((node) => parseSkillInsight(node))
+        .filter((state) => Boolean(state))
+        .sort((a, b) => b.score - a.score || b.uses - a.uses || b.updatedAt - a.updatedAt)
+        .slice(0, boundedLimit);
+    return {
+        source: "graph-store",
+        transport: config.graphPolicy.transport,
+        storePath: (0, paths_1.resolveGraphStorePath)(config),
+        skills,
+    };
+}
+async function runTaskResult(task, configPath) {
+    const config = (0, resolve_1.resolveConfig)(configPath);
+    applyOpenBmbRuntimeEnv(config);
+    const eventsPath = (0, paths_1.resolveLearningPath)(config, "eventsPath");
+    try {
+        const graphClient = (0, client_factory_1.createGraphClient)(config);
+        if (config.graphPolicy.autoIndexOnRun) {
+            const indexOptions = config.graphPolicy.includeExtensions
+                ? { includeExtensions: config.graphPolicy.includeExtensions }
+                : undefined;
+            await (0, file_indexer_1.indexWorkspaceFiles)(graphClient, config.graphPolicy.workspaceRoot ?? process.cwd(), {
+                ...indexOptions,
+            });
+        }
+        const embeddingOptions = buildEmbeddingOptions(config);
+        const orchestrateOptions = {
+            graphClient,
+            enableAutoGraphSync: config.graphPolicy.enableAutoBuild,
+            maxContextTokens: config.graphPolicy.maxContextTokens,
+            enableEpisodicMemory: config.learningPolicy.enableFlywheel,
+            enableLlmAgents: config.tiers.smart.provider === "openbmb" || config.tiers.economy.provider === "openbmb",
+            enableLlmTriage: config.tiers.smart.provider === "openbmb" || config.tiers.economy.provider === "openbmb",
+            ...(configPath ? { configPath } : {}),
+            ...embeddingOptions,
+            ...(config.skillPolicy?.enableSkillFlywheel
+                ? {
+                    enableSkillFlywheel: true,
+                    ...(config.skillPolicy.maxSkillHints !== undefined
+                        ? { skillHintsLimit: config.skillPolicy.maxSkillHints }
+                        : {}),
+                }
+                : { enableSkillFlywheel: false }),
+            providerHealth: (0, provider_health_1.buildProviderHealthMap)(config),
+            ...(config.routingPolicy?.enableDynamicRouting
+                ? { providerFallbackChain: (0, provider_health_1.buildFallbackChain)(config) }
+                : {}),
+            ...(config.graphPolicy.enableNearLosslessMode !== undefined
+                ? { enableNearLosslessMode: config.graphPolicy.enableNearLosslessMode }
+                : {}),
+            ...(config.graphPolicy.layerQuota ? { layerQuota: config.graphPolicy.layerQuota } : {}),
+        };
+        const result = await (0, orchestrator_1.orchestrate)({ task }, orchestrateOptions);
+        (0, learning_events_1.appendFeedbackEvent)(eventsPath, {
+            query: task,
+            passed: result.status === "COMPLETED",
+            tokenCost: extractTokenCost(result.feedback),
+            retries: Math.max(0, result.attempts - 1),
+        });
+        return {
+            status: result.status,
+            attempts: result.attempts,
+            feedback: result.feedback,
+        };
+    }
+    catch (error) {
+        (0, learning_events_1.appendFeedbackEvent)(eventsPath, {
+            query: task,
+            passed: false,
+            tokenCost: 0,
+            retries: 0,
+        });
+        throw error;
+    }
+}
+async function runTask(task, configPath) {
+    const result = await runTaskResult(task, configPath);
+    return `status=${result.status}; attempts=${result.attempts}; feedback=${result.feedback}`;
+}
+function diagnoseRoutingResult(configPath) {
+    const config = (0, resolve_1.resolveConfig)(configPath);
+    const health = (0, provider_health_1.buildProviderHealthMap)(config);
+    const chain = (0, provider_health_1.buildFallbackChain)(config);
+    const resolve = (role) => {
+        if (!config.routingPolicy?.enableDynamicRouting) {
+            return (0, model_router_1.resolveModelForRole)(role);
+        }
+        return (0, model_router_1.resolveModelWithFallback)(role, health, chain);
+    };
+    const planner = resolve("planner");
+    const worker = resolve("worker");
+    const validator = resolve("validator");
+    return {
+        dynamicRouting: config.routingPolicy?.enableDynamicRouting ?? false,
+        health,
+        priority: chain,
+        planner: {
+            provider: planner.provider,
+            model: planner.model,
+            fallbackApplied: planner.fallbackApplied,
+        },
+        worker: {
+            provider: worker.provider,
+            model: worker.model,
+            fallbackApplied: worker.fallbackApplied,
+        },
+        validator: {
+            provider: validator.provider,
+            model: validator.model,
+            fallbackApplied: validator.fallbackApplied,
+        },
+    };
+}
+function diagnoseRouting(configPath) {
+    const result = diagnoseRoutingResult(configPath);
+    return [
+        `dynamicRouting=${result.dynamicRouting ? "on" : "off"}`,
+        `health=openai:${result.health.openai},anthropic:${result.health.anthropic},bailian:${result.health.bailian},doubao:${result.health.doubao},openbmb:${result.health.openbmb}`,
+        `priority=${result.priority.join(",")}`,
+        `planner=${result.planner.provider}/${result.planner.model}${result.planner.fallbackApplied ? ":fallback" : ""}`,
+        `worker=${result.worker.provider}/${result.worker.model}${result.worker.fallbackApplied ? ":fallback" : ""}`,
+        `validator=${result.validator.provider}/${result.validator.model}${result.validator.fallbackApplied ? ":fallback" : ""}`,
+    ].join("; ");
+}
+async function getSettingsPanelStatus(configPath) {
+    const config = (0, resolve_1.resolveConfig)(configPath);
+    const snapshot = await inspectGraph(configPath, { nodeLimit: 1, edgeLimit: 1 });
+    const storePath = (0, paths_1.resolveGraphStorePath)(config);
+    let graphLastModified = null;
+    if ((0, node_fs_1.existsSync)(storePath)) {
+        graphLastModified = new Date((0, node_fs_1.statSync)(storePath).mtimeMs).toISOString();
+    }
+    return {
+        graphNodeCount: snapshot.nodeCount,
+        graphEdgeCount: snapshot.edgeCount,
+        graphLastModified,
+        diagnoseSummary: diagnoseRouting(configPath),
+        overlayKeys: (0, merge_1.listConfigOverlayKeys)(),
+        baseConfigPath: (0, node_fs_1.existsSync)("graphflow.config.json") ? "graphflow.config.json" : "（未创建）",
+    };
+}
+function runLearningNightlyResult(configPath) {
+    const config = (0, resolve_1.resolveConfig)(configPath);
+    const summary = (0, nightly_trainer_1.runNightlyLearning)(config);
+    return {
+        events: summary.totalEvents,
+        passRate: summary.passRate,
+        avgTokens: summary.averageTokenCost,
+        canary: summary.canaryAllowed ? "allow" : "block",
+        reason: summary.canaryReason,
+        dataset: summary.exportedPath,
+    };
+}
+function runLearningNightly(configPath) {
+    const result = runLearningNightlyResult(configPath);
+    return [
+        `events=${result.events}`,
+        `passRate=${result.passRate.toFixed(3)}`,
+        `avgTokens=${result.avgTokens.toFixed(1)}`,
+        `canary=${result.canary}`,
+        `reason=${result.reason}`,
+        `dataset=${result.dataset}`,
+    ].join("; ");
+}
+function planAndBrainstormResult(task) {
+    const mode = (0, triage_1.triageTask)(task);
+    const ideas = (0, brainstormer_1.brainstormTask)(task);
+    const nodes = (0, planner_1.planTasks)(task).map((node) => ({
+        id: node.id,
+        description: node.description,
+        dependencies: node.dependencies,
+    }));
+    return {
+        mode,
+        ideas,
+        nodes,
+    };
+}
+function planAndBrainstorm(task) {
+    const result = planAndBrainstormResult(task);
+    return [
+        `mode=${result.mode}`,
+        `ideas=${result.ideas.join(" | ")}`,
+        `plan=${result.nodes
+            .map((node) => `${node.id}[${node.dependencies.join(",") || "-"}]:${node.description}`)
+            .join(" | ")}`,
+    ].join("; ");
+}
+var agent_mcp_installer_1 = require("../../integrations/agent-mcp-installer");
+Object.defineProperty(exports, "buildMcpServerNode", { enumerable: true, get: function () { return agent_mcp_installer_1.buildMcpServerNode; } });
+Object.defineProperty(exports, "detectInstalledAgents", { enumerable: true, get: function () { return agent_mcp_installer_1.detectInstalledAgents; } });
+Object.defineProperty(exports, "formatModelConfigGuide", { enumerable: true, get: function () { return agent_mcp_installer_1.formatModelConfigGuide; } });
+Object.defineProperty(exports, "installMcpToDetectedAgents", { enumerable: true, get: function () { return agent_mcp_installer_1.installMcpToDetectedAgents; } });
+function extractTokenCost(feedback) {
+    const match = feedback.match(/tokens=(\d+)/);
+    if (match && match[1]) {
+        return Number(match[1]);
+    }
+    return Math.max(1, Math.ceil(feedback.length / 4));
+}
+function loadGraphStore(config) {
+    const transport = config.graphPolicy.transport;
+    if (transport === "memory") {
+        return { nodes: [], edges: [] };
+    }
+    if (transport === "sqlite") {
+        const dbPath = (0, paths_1.resolveGraphStorePath)(config);
+        try {
+            const client = new sqlite_client_1.GraphifySqliteClient(dbPath);
+            const snapshot = client.readSnapshot();
+            client.close();
+            return snapshot;
+        }
+        catch {
+            const fallbackPath = dbPath.replace(/\.sqlite$/i, ".json");
+            return readFileGraphStore(fallbackPath);
+        }
+    }
+    return readFileGraphStore((0, paths_1.resolveGraphStorePath)(config));
+}
+async function resolveGraphStoreAfterIndex(config, graphClient) {
+    if (config.graphPolicy.transport === "memory" && graphClient.readSnapshot) {
+        return graphClient.readSnapshot();
+    }
+    return loadGraphStore(config);
+}
+function readFileGraphStore(storePath) {
+    if (!storePath || !(0, node_fs_1.existsSync)(storePath)) {
+        return { nodes: [], edges: [] };
+    }
+    try {
+        const raw = (0, node_fs_1.readFileSync)(storePath, "utf8");
+        if (!raw.trim()) {
+            return { nodes: [], edges: [] };
+        }
+        const parsed = JSON.parse(raw);
+        return {
+            nodes: parsed.nodes ?? [],
+            edges: parsed.edges ?? [],
+        };
+    }
+    catch {
+        return { nodes: [], edges: [] };
+    }
+}
+function getFileSize(path) {
+    try {
+        return (0, node_fs_1.statSync)(path).size;
+    }
+    catch {
+        return 0;
+    }
+}
+async function sha256File(path) {
+    const hash = (0, node_crypto_1.createHash)("sha256");
+    const stream = (0, node_fs_1.createReadStream)(path);
+    for await (const chunk of stream) {
+        hash.update(chunk);
+    }
+    return hash.digest("hex");
+}
+function readRawConfig(configPath) {
+    if (!(0, node_fs_1.existsSync)(configPath)) {
+        return undefined;
+    }
+    try {
+        return JSON.parse((0, node_fs_1.readFileSync)(configPath, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+function estimateRawContextTokens(store, query, compressedTokens) {
+    const matching = store.nodes.filter((node) => {
+        const haystack = `${node.id} ${node.type} ${node.content}`.toLowerCase();
+        const terms = query
+            .toLowerCase()
+            .split(/[^a-z0-9_]+/g)
+            .filter((item) => item.length >= 2);
+        return terms.length === 0 || terms.some((term) => haystack.includes(term));
+    });
+    const nodes = matching.length > 0 ? matching : store.nodes;
+    const rawTokens = nodes.reduce((sum, node) => sum + estimateTokenCount(`${node.id}\n${node.type}\n${node.content}`), 0);
+    return Math.max(compressedTokens, rawTokens, estimateTokenCount(query));
+}
+function calculateSavingsPercent(rawTokens, compressedTokens) {
+    if (rawTokens <= 0) {
+        return 0;
+    }
+    return Math.max(0, Math.min(100, Math.round(((rawTokens - compressedTokens) / rawTokens) * 100)));
+}
+function calculateBudgetUsedPercent(compressedTokens, maxContextTokens) {
+    if (maxContextTokens <= 0) {
+        return 0;
+    }
+    return Math.max(0, Math.round((compressedTokens / maxContextTokens) * 100));
+}
+function estimateTokenCount(text) {
+    try {
+        const { encode } = require("gpt-tokenizer/model/gpt-4o");
+        return Math.max(1, encode(text).length);
+    }
+    catch {
+        return Math.max(1, Math.ceil(text.replace(/\s+/g, " ").trim().length / 4));
+    }
+}
+function compactPreview(content, maxLength) {
+    const compacted = content.replace(/\s+/g, " ").trim();
+    if (compacted.length <= maxLength) {
+        return compacted;
+    }
+    return `${compacted.slice(0, Math.max(0, maxLength - 1))}\u2026`;
+}
+function parseSkillInsight(node) {
+    try {
+        const parsed = JSON.parse(node.content);
+        if (!parsed.id || !parsed.name) {
+            return undefined;
+        }
+        return {
+            id: parsed.id,
+            name: parsed.name,
+            score: parsed.score ?? 0,
+            uses: parsed.uses ?? 0,
+            lastOutcome: parsed.lastOutcome === "fail" ? "fail" : "pass",
+            updatedAt: parsed.updatedAt ?? 0,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=runtime.js.map