pulseed 0.5.4 → 0.6.0

package/README.md

@@ -58,7 +58,6 @@ PulSeed will guide provider and adapter setup when needed.
 
 - [Get Started](docs/getting-started.md)
 - [Docs Index](docs/index.md)
-- [Use Cases](docs/usecase.md)
 - [Runtime](docs/runtime.md)
 - [Configuration](docs/configuration.md)
 - [Status](docs/status.md)
@@ -97,17 +96,22 @@ PulSeed will guide provider and adapter setup when needed.
 - `pulseed schedule ...` for schedule management
 - Lower-level commands for scripting, diagnostics, and compatibility
 
-## Use Cases
+## Achievements
 
-PulSeed is a fit when the work is bigger than one prompt and needs follow-through:
+PulSeed joined [Kaggle Playground Series S6E4](https://www.kaggle.com/competitions/playground-series-s6e4).
 
-- keep a codebase moving toward a maintenance goal
-- track a business KPI and adjust strategy as results change
-- coordinate recurring reports, reminders, and external actions
-- observe external data sources and ask for confirmation when a human decision
-  is required
+| Area | Result |
+| --- | --- |
+| Long-running workflow | It has been running straight over 10 hours and made decent progress. |
+| Local OOF balanced accuracy | Improved from early 0.45-level baselines to `0.970413051791`. |
+| Exploration path | CatBoost-focused ensembles, probability adjustment, and post-OOF calibration. |
+| Current best local artifact | Preserved full OOF predictions and per-class recall. |
 
-More detailed examples live in [Use Cases](docs/usecase.md).
+Current best per-class recall:
+
+- High: `0.957351611214`
+- Low: `0.994598788377`
+- Medium: `0.959288755783`
 
 ## Docs and Community
 

package/dist/adapters/datasources/artifact-metric-datasource.d.ts

@@ -0,0 +1,18 @@
+import type { DataSourceConfig, DataSourceQuery, DataSourceResult, DataSourceType } from "../../base/types/data-source.js";
+import type { IDataSourceAdapter } from "../../platform/observation/data-source-adapter.js";
+export declare function createWorkspaceArtifactMetricDataSource(workspacePath?: string): ArtifactMetricDataSourceAdapter;
+export declare class ArtifactMetricDataSourceAdapter implements IDataSourceAdapter {
+    readonly sourceId: string;
+    readonly sourceType: DataSourceType;
+    readonly config: DataSourceConfig;
+    constructor(config: DataSourceConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    healthCheck(): Promise<boolean>;
+    getSupportedDimensions(): string[];
+    supportsDimension(dimensionName: string): boolean;
+    query(params: DataSourceQuery): Promise<DataSourceResult>;
+    private workspaceRoot;
+    private scanOptions;
+}
+//# sourceMappingURL=artifact-metric-datasource.d.ts.map

package/dist/adapters/datasources/artifact-metric-datasource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifact-metric-datasource.d.ts","sourceRoot":"","sources":["../../../src/adapters/datasources/artifact-metric-datasource.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,cAAc,EACf,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AAuE5F,wBAAgB,uCAAuC,CAAC,aAAa,SAAgB,GAAG,+BAA+B,CAStH;AAED,qBAAa,+BAAgC,YAAW,kBAAkB;IACxE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAqB;IACxD,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;gBAEtB,MAAM,EAAE,gBAAgB;IAK9B,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAIxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IASrC,sBAAsB,IAAI,MAAM,EAAE;IAWlC,iBAAiB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO;IAI3C,KAAK,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAyE/D,OAAO,CAAC,aAAa;IAKrB,OAAO,CAAC,WAAW;CAoBpB"}

package/dist/adapters/datasources/artifact-metric-datasource.js

@@ -0,0 +1,592 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+const BUILTIN_SOURCE_ID = "ds_builtin_workspace_artifacts";
+const DEFAULT_METRIC_FILE_NAMES = ["metrics.json", "result.json"];
+const DEFAULT_ARTIFACT_ROOTS = ["artifacts", "runs", "reports", "outputs", "results", "logs"];
+const DEFAULT_EXCLUDE_DIRS = new Set([
+    ".cache",
+    ".git",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".venv",
+    "__pycache__",
+    "env",
+    "node_modules",
+    "venv",
+]);
+const DEFAULT_EXCLUDE_PATHS = new Set(["data/raw"]);
+const DEFAULT_MAX_METRIC_FILES = 5_000;
+const DEFAULT_MAX_ARTIFACT_FILES = 100_000;
+const DEFAULT_MAX_CANDIDATES = 200;
+const MAX_RAW_CANDIDATES = 25;
+export function createWorkspaceArtifactMetricDataSource(workspacePath = process.cwd()) {
+    return new ArtifactMetricDataSourceAdapter({
+        id: BUILTIN_SOURCE_ID,
+        name: "builtin:workspace artifact metrics",
+        type: "artifact_metric",
+        connection: { path: workspacePath },
+        enabled: true,
+        created_at: new Date().toISOString(),
+    });
+}
+export class ArtifactMetricDataSourceAdapter {
+    sourceId;
+    sourceType = "artifact_metric";
+    config;
+    constructor(config) {
+        this.config = config;
+        this.sourceId = config.id;
+    }
+    async connect() {
+        await fs.access(this.workspaceRoot());
+    }
+    async disconnect() {
+        // no persistent connection
+    }
+    async healthCheck() {
+        try {
+            await fs.access(this.workspaceRoot());
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    getSupportedDimensions() {
+        const dimensions = new Set([
+            ...Object.keys(this.config.dimension_mapping ?? {}),
+            ...Object.keys(this.config.connection.dimension_metrics ?? {}),
+            ...Object.keys(this.config.connection.dimension_aggregations ?? {}),
+            "validated_experiment_count",
+            "durable_artifact_count",
+        ]);
+        return Array.from(dimensions).sort();
+    }
+    supportsDimension(dimensionName) {
+        return this.getSupportedDimensions().includes(dimensionName) || isRecognizedBestMetricDimension(dimensionName);
+    }
+    async query(params) {
+        const root = this.workspaceRoot();
+        const expression = this.config.dimension_mapping?.[params.dimension_name] ?? params.expression;
+        const aggregation = resolveAggregation(params.dimension_name, expression, this.config);
+        const timestamp = new Date().toISOString();
+        const options = this.scanOptions();
+        if (aggregation === "file_count") {
+            const count = await countArtifactFiles(root, options);
+            return {
+                value: count,
+                raw: {
+                    root,
+                    aggregation,
+                    file_count: count,
+                    discovery: discoveryRaw(options),
+                },
+                timestamp,
+                source_id: this.sourceId,
+            };
+        }
+        const keys = resolveMetricKeys(params.dimension_name, expression, this.config);
+        const candidates = await discoverMetricCandidates(root, options, keys);
+        const observations = await readMetricObservations(candidates);
+        const evidenceCandidates = buildEvidenceCandidates(observations, keys, aggregation === "min" ? "min" : "max");
+        if (aggregation === "count") {
+            const matched = observations.filter((observation) => hasAnyMetric(observation, keys));
+            return {
+                value: matched.length,
+                raw: {
+                    root,
+                    aggregation,
+                    inspected_metric_files: candidates.length,
+                    matched_metric_files: matched.length,
+                    metric_keys: keys,
+                    discovery: discoveryRaw(options),
+                    candidates: rawCandidates(candidates),
+                    evidence_candidates: evidenceCandidates,
+                    conflicts: detectMetricConflicts(params.dimension_name, observations, keys),
+                    stale_candidates: staleRaw(observations),
+                    strategic_correctness: "not_evaluated",
+                },
+                timestamp,
+                source_id: this.sourceId,
+            };
+        }
+        const match = selectMetric(observations, keys, aggregation);
+        return {
+            value: match?.value ?? 0,
+            raw: {
+                root,
+                aggregation,
+                inspected_metric_files: candidates.length,
+                metric_keys: keys,
+                selected_path: match?.path ?? null,
+                selected_key: match?.key ?? null,
+                selected_value: match?.value ?? 0,
+                selected: match,
+                discovery: discoveryRaw(options),
+                candidates: rawCandidates(candidates),
+                evidence_candidates: evidenceCandidates,
+                conflicts: detectMetricConflicts(params.dimension_name, observations, keys),
+                stale_candidates: staleRaw(observations),
+                strategic_correctness: "not_evaluated",
+            },
+            timestamp,
+            source_id: this.sourceId,
+        };
+    }
+    workspaceRoot() {
+        const configuredPath = this.config.connection.path;
+        return configuredPath ? path.resolve(configuredPath) : process.cwd();
+    }
+    scanOptions() {
+        return {
+            metricFileNames: new Set(this.config.connection.metric_file_names ?? DEFAULT_METRIC_FILE_NAMES),
+            artifactRoots: unique([
+                ...(this.config.connection.artifact_roots ?? []),
+                ...(this.config.connection.artifact_roots ? [] : DEFAULT_ARTIFACT_ROOTS),
+            ].map(normalizeRelativePath)),
+            includePaths: unique((this.config.connection.include_paths ?? []).map(normalizeRelativePath)),
+            parserHints: new Set(this.config.connection.parser_hints ?? ["json"]),
+            excludeDirs: new Set([...(this.config.connection.exclude_dirs ?? []), ...DEFAULT_EXCLUDE_DIRS]),
+            excludePaths: new Set([
+                ...Array.from(DEFAULT_EXCLUDE_PATHS),
+                ...(this.config.connection.exclude_paths ?? []),
+            ].map(normalizeRelativePath)),
+            maxMetricFiles: this.config.connection.max_metric_files ?? DEFAULT_MAX_METRIC_FILES,
+            maxArtifactFiles: this.config.connection.max_artifact_files ?? DEFAULT_MAX_ARTIFACT_FILES,
+            maxCandidates: this.config.connection.max_candidates ?? DEFAULT_MAX_CANDIDATES,
+            staleAfterMs: this.config.connection.stale_after_ms,
+        };
+    }
+}
+async function discoverMetricCandidates(root, options, keys) {
+    const discovered = new Map();
+    for (const includePath of options.includePaths) {
+        if (discovered.size >= options.maxMetricFiles)
+            break;
+        const absolute = path.resolve(root, includePath);
+        if (!isInsideRoot(root, absolute) || !(await isFile(absolute)))
+            continue;
+        if (!options.metricFileNames.has(path.basename(absolute)))
+            continue;
+        const candidate = await buildMetricCandidate(root, absolute, options, keys);
+        discovered.set(candidate.path, candidate);
+    }
+    const searchRoots = await resolveSearchRoots(root, options);
+    for (const searchRoot of searchRoots) {
+        if (discovered.size >= options.maxMetricFiles)
+            break;
+        await walkFiles(root, searchRoot, options, async (filePath) => {
+            if (discovered.size >= options.maxMetricFiles)
+                return;
+            if (!options.metricFileNames.has(path.basename(filePath)))
+                return;
+            const candidate = await buildMetricCandidate(root, filePath, options, keys);
+            discovered.set(candidate.path, candidate);
+        });
+    }
+    return Array.from(discovered.values())
+        .sort(compareCandidates)
+        .slice(0, options.maxCandidates);
+}
+async function resolveSearchRoots(root, options) {
+    const roots = [];
+    for (const includePath of [...options.includePaths, ...options.artifactRoots]) {
+        const absolute = path.resolve(root, includePath);
+        if (!isInsideRoot(root, absolute))
+            continue;
+        if (await isDirectory(absolute))
+            roots.push(absolute);
+    }
+    if (roots.length === 0)
+        roots.push(root);
+    return unique(roots);
+}
+async function buildMetricCandidate(root, filePath, options, keys) {
+    const stats = await fs.stat(filePath);
+    const relativePath = normalizeRelativePath(path.relative(root, filePath));
+    const reasons = [];
+    let score = 0;
+    if (options.metricFileNames.has(path.basename(filePath))) {
+        score += 35;
+        reasons.push("metric filename match");
+    }
+    const matchedRoot = options.artifactRoots.find((rootHint) => relativePath === rootHint || relativePath.startsWith(`${rootHint}/`));
+    if (matchedRoot) {
+        score += 20;
+        reasons.push(`artifact root match: ${matchedRoot}`);
+    }
+    for (const key of keys) {
+        if (relativePath.toLowerCase().includes(key.toLowerCase())) {
+            score += 8;
+            reasons.push(`path metric hint: ${key}`);
+            break;
+        }
+    }
+    const mtime = stats.mtime;
+    if (Date.now() - mtime.getTime() < 24 * 60 * 60 * 1000) {
+        score += 10;
+        reasons.push("recent artifact");
+    }
+    const stale = options.staleAfterMs !== undefined && Date.now() - mtime.getTime() > options.staleAfterMs;
+    if (stale) {
+        score -= 30;
+        reasons.push("stale artifact");
+    }
+    return {
+        path: filePath,
+        relativePath,
+        updatedTime: mtime.toISOString(),
+        candidateScore: score,
+        reasons,
+        stale,
+    };
+}
+async function countArtifactFiles(root, options) {
+    let count = 0;
+    await walkFiles(root, root, options, async () => {
+        if (count < options.maxArtifactFiles)
+            count += 1;
+    });
+    return count;
+}
+async function walkFiles(root, startDir, options, onFile) {
+    async function visit(dir) {
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            const relPath = normalizeRelativePath(path.relative(root, fullPath));
+            if (entry.isDirectory()) {
+                if (shouldSkipDirectory(entry.name, relPath, options))
+                    continue;
+                await visit(fullPath);
+            }
+            else if (entry.isFile()) {
+                await onFile(fullPath);
+            }
+        }
+    }
+    await visit(startDir);
+}
+function shouldSkipDirectory(name, relPath, options) {
+    if (options.excludeDirs.has(name))
+        return true;
+    for (const excludedPath of options.excludePaths) {
+        if (relPath === excludedPath || relPath.startsWith(`${excludedPath}/`))
+            return true;
+    }
+    return false;
+}
+async function readMetricObservations(candidates) {
+    const observations = [];
+    for (const candidate of candidates) {
+        try {
+            const parsed = JSON.parse(await fs.readFile(candidate.path, "utf8"));
+            const metrics = extractNumericMetrics(parsed);
+            if (metrics.length > 0) {
+                observations.push({
+                    ...candidate,
+                    parser: "json",
+                    metrics,
+                    extractionConfidence: Math.max(...metrics.map((metric) => metric.confidence)),
+                });
+            }
+        }
+        catch {
+            // Ignore incomplete or invalid artifacts while the long-running process is writing.
+        }
+    }
+    return observations;
+}
+function extractNumericMetrics(value) {
+    const metrics = [];
+    if (!isRecord(value))
+        return metrics;
+    for (const [key, field] of Object.entries(value)) {
+        addNumber(metrics, key, key, field, 0.95);
+    }
+    const nestedMetrics = value["metrics"];
+    if (isRecord(nestedMetrics)) {
+        for (const [key, field] of Object.entries(nestedMetrics)) {
+            addNumber(metrics, key, `metrics.${key}`, field, 0.90);
+        }
+    }
+    const allMetrics = value["all_metrics"];
+    if (isRecord(allMetrics)) {
+        for (const [key, field] of Object.entries(allMetrics)) {
+            addNumber(metrics, key, `all_metrics.${key}`, field, 0.90);
+        }
+    }
+    const metricName = typeof value["metric_name"] === "string" ? value["metric_name"] : null;
+    if (metricName) {
+        addNumber(metrics, metricName, "score", value["score"], 0.85);
+        addNumber(metrics, metricName, "cv_score", value["cv_score"], 0.85);
+    }
+    const evidence = value["evidence"];
+    if (Array.isArray(evidence)) {
+        for (const [index, item] of evidence.entries()) {
+            if (!isRecord(item))
+                continue;
+            const label = typeof item["label"] === "string" ? item["label"] : null;
+            if (!label)
+                continue;
+            addNumber(metrics, label, `evidence.${index}.value`, item["value"], 0.80);
+        }
+    }
+    return metrics;
+}
+function addNumber(metrics, key, keyPath, value, confidence) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        metrics.push({ key, keyPath, value, confidence });
+    }
+}
+function hasAnyMetric(observation, keys) {
+    if (keys.length === 0)
+        return observation.metrics.length > 0;
+    return keys.some((key) => observation.metrics.some((metric) => metric.key === key));
+}
+function selectMetric(observations, keys, aggregation) {
+    const matches = matchingMetrics(observations, keys);
+    if (matches.length === 0)
+        return null;
+    const sorted = [...matches].sort((left, right) => compareMetricMatches(left, right, aggregation));
+    const best = sorted[0];
+    return {
+        path: best.observation.path,
+        relativePath: best.observation.relativePath,
+        key: best.metric.key,
+        keyPath: best.metric.keyPath,
+        value: best.metric.value,
+        parser: best.observation.parser,
+        updatedTime: best.observation.updatedTime,
+        extractionConfidence: best.metric.confidence,
+        candidateScore: best.observation.candidateScore,
+        stale: best.observation.stale,
+    };
+}
+function matchingMetrics(observations, keys) {
+    const wanted = new Set(keys);
+    const matches = [];
+    for (const observation of observations) {
+        for (const metric of observation.metrics) {
+            if (wanted.size === 0 || wanted.has(metric.key)) {
+                matches.push({ observation, metric });
+            }
+        }
+    }
+    return matches;
+}
+function compareMetricMatches(left, right, aggregation) {
+    const leftQuality = qualityBucket(left.observation, left.metric);
+    const rightQuality = qualityBucket(right.observation, right.metric);
+    if (leftQuality !== rightQuality)
+        return rightQuality - leftQuality;
+    if (left.metric.value !== right.metric.value) {
+        return aggregation === "max"
+            ? right.metric.value - left.metric.value
+            : left.metric.value - right.metric.value;
+    }
+    if (left.metric.confidence !== right.metric.confidence)
+        return right.metric.confidence - left.metric.confidence;
+    if (left.observation.candidateScore !== right.observation.candidateScore)
+        return right.observation.candidateScore - left.observation.candidateScore;
+    return Date.parse(right.observation.updatedTime) - Date.parse(left.observation.updatedTime);
+}
+function qualityBucket(observation, metric) {
+    if (observation.stale)
+        return 0;
+    if (metric.confidence < 0.85)
+        return 1;
+    return 2;
+}
+function detectMetricConflicts(dimensionName, observations, keys) {
+    const grouped = new Map();
+    for (const match of matchingMetrics(observations, keys)) {
+        const group = grouped.get(match.metric.key) ?? [];
+        group.push(match);
+        grouped.set(match.metric.key, group);
+    }
+    const conflicts = [];
+    for (const [metricKey, matches] of grouped) {
+        const conflict = buildConflict(metricKey, matches);
+        if (conflict)
+            conflicts.push(conflict);
+    }
+    if (keys.length > 1) {
+        const aliasConflict = buildConflict(`dimension:${dimensionName}`, matchingMetrics(observations, keys));
+        if (aliasConflict)
+            conflicts.push(aliasConflict);
+    }
+    return conflicts;
+}
+function buildConflict(metricKey, matches) {
+    const values = new Set(matches.map((match) => match.metric.value));
+    if (values.size <= 1)
+        return null;
+    return {
+        metricKey,
+        candidates: matches
+            .sort((left, right) => Date.parse(right.observation.updatedTime) - Date.parse(left.observation.updatedTime))
+            .slice(0, MAX_RAW_CANDIDATES)
+            .map(({ observation, metric }) => ({
+            path: observation.relativePath,
+            keyPath: metric.keyPath,
+            value: metric.value,
+            updatedTime: observation.updatedTime,
+            extractionConfidence: metric.confidence,
+            stale: observation.stale,
+        })),
+    };
+}
+function buildEvidenceCandidates(observations, keys, aggregation) {
+    return matchingMetrics(observations, keys)
+        .sort((left, right) => compareMetricMatches(left, right, aggregation))
+        .slice(0, MAX_RAW_CANDIDATES)
+        .map(({ observation, metric }) => ({
+        path: observation.relativePath,
+        metric_key: metric.key,
+        metric_key_path: metric.keyPath,
+        value: metric.value,
+        parser: observation.parser,
+        updated_time: observation.updatedTime,
+        extraction_confidence: metric.confidence,
+        candidate_score: observation.candidateScore,
+        stale: observation.stale,
+        reasons: observation.reasons,
+        strategic_correctness: "not_evaluated",
+    }));
+}
+function rawCandidates(candidates) {
+    return candidates.slice(0, MAX_RAW_CANDIDATES).map((candidate) => ({
+        path: candidate.relativePath,
+        updated_time: candidate.updatedTime,
+        candidate_score: candidate.candidateScore,
+        stale: candidate.stale,
+        reasons: candidate.reasons,
+    }));
+}
+function staleRaw(observations) {
+    return observations
+        .filter((observation) => observation.stale)
+        .slice(0, MAX_RAW_CANDIDATES)
+        .map((observation) => ({
+        path: observation.relativePath,
+        updated_time: observation.updatedTime,
+        extraction_confidence: observation.extractionConfidence,
+    }));
+}
+function discoveryRaw(options) {
+    return {
+        artifact_roots: options.artifactRoots,
+        include_paths: options.includePaths,
+        metric_file_names: Array.from(options.metricFileNames),
+        max_metric_files: options.maxMetricFiles,
+        max_candidates: options.maxCandidates,
+        parser_hints: Array.from(options.parserHints),
+        stale_after_ms: options.staleAfterMs ?? null,
+    };
+}
+function compareCandidates(left, right) {
+    if (left.candidateScore !== right.candidateScore)
+        return right.candidateScore - left.candidateScore;
+    return Date.parse(right.updatedTime) - Date.parse(left.updatedTime);
+}
+function resolveAggregation(dimensionName, expression, config) {
+    const configured = config.connection.dimension_aggregations?.[dimensionName];
+    if (configured)
+        return configured;
+    if (expression?.startsWith("min:"))
+        return "min";
+    if (expression?.startsWith("max:"))
+        return "max";
+    if (expression?.startsWith("count:") || expression === "count_valid_metrics")
+        return "count";
+    if (expression === "file_count")
+        return "file_count";
+    if (dimensionName === "durable_artifact_count")
+        return "file_count";
+    if (dimensionName.endsWith("_count"))
+        return "count";
+    return prefersLowerMetric(dimensionName) ? "min" : "max";
+}
+function resolveMetricKeys(dimensionName, expression, config) {
+    const configured = config.connection.dimension_metrics?.[dimensionName];
+    if (configured && configured.length > 0)
+        return unique(configured);
+    if (expression) {
+        const [, rest] = /^(?:min|max|count):(.*)$/.exec(expression) ?? [];
+        const raw = rest ?? (expression === "count_valid_metrics" || expression === "file_count" ? "" : expression);
+        const keys = raw.split(",").map((item) => item.trim()).filter(Boolean);
+        if (keys.length > 0)
+            return unique(keys);
+    }
+    if (dimensionName.endsWith("_count"))
+        return [];
+    return deriveMetricKeys(dimensionName);
+}
+function deriveMetricKeys(dimensionName) {
+    const keys = new Set([dimensionName]);
+    const withoutBest = dimensionName.startsWith("best_") ? dimensionName.slice("best_".length) : dimensionName;
+    keys.add(withoutBest);
+    for (const prefix of ["oof_", "cv_", "mean_", "best_"]) {
+        if (withoutBest.startsWith(prefix)) {
+            keys.add(withoutBest.slice(prefix.length));
+        }
+    }
+    if (withoutBest.includes("balanced_accuracy")) {
+        keys.add("balanced_accuracy");
+        keys.add("oof_balanced_accuracy");
+        keys.add("cv_balanced_accuracy");
+    }
+    if (withoutBest.includes("accuracy")) {
+        keys.add("accuracy");
+        keys.add("oof_accuracy");
+        keys.add("cv_accuracy");
+    }
+    if (withoutBest.includes("score")) {
+        keys.add("score");
+        keys.add("cv_score");
+    }
+    return unique(Array.from(keys));
+}
+function isRecognizedBestMetricDimension(dimensionName) {
+    return dimensionName.startsWith("best_") && deriveMetricKeys(dimensionName).length > 2;
+}
+function prefersLowerMetric(dimensionName) {
+    return /loss|error|rmse|mae|mse/i.test(dimensionName);
+}
+function normalizeRelativePath(value) {
+    return value.split(path.sep).join("/").replace(/^\.\//, "");
+}
+function isInsideRoot(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+async function isDirectory(filePath) {
+    try {
+        return (await fs.stat(filePath)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function isFile(filePath) {
+    try {
+        return (await fs.stat(filePath)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function unique(values) {
+    return Array.from(new Set(values.filter(Boolean)));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=artifact-metric-datasource.js.map