@dotsetlabs/bellwether 2.1.0 → 2.1.2

package/dist/dashboard/runtime/artifact-index.js

@@ -0,0 +1,238 @@
+import { existsSync, readFileSync, statSync } from 'fs';
+import { isAbsolute, join, resolve } from 'path';
+import { getGoldenStorePath } from '../../baseline/golden-output.js';
+import { PATHS, CONTRACT_TESTING } from '../../constants.js';
+import { loadConfig } from '../../config/loader.js';
+import { CONFIG_DEFAULTS } from '../../config/defaults.js';
+import { getConfigDocument } from './config-service.js';
+function resolvePathFromCwd(cwd, value) {
+    if (isAbsolute(value)) {
+        return value;
+    }
+    return resolve(cwd, value);
+}
+function resolvePathFromOutput(outputDir, value) {
+    if (isAbsolute(value)) {
+        return value;
+    }
+    return resolve(outputDir, value);
+}
+function resolveComparePath(cwd, outputDir, comparePath) {
+    if (isAbsolute(comparePath)) {
+        return comparePath;
+    }
+    const outputCandidate = resolve(outputDir, comparePath);
+    const cwdCandidate = resolve(cwd, comparePath);
+    if (existsSync(outputCandidate) || !existsSync(cwdCandidate)) {
+        return outputCandidate;
+    }
+    return cwdCandidate;
+}
+function loadConfigOrDefaults(cwd, configPath) {
+    try {
+        const configDocument = getConfigDocument(cwd, configPath);
+        if (!configDocument.exists) {
+            return null;
+        }
+        return loadConfig(configDocument.absolutePath);
+    }
+    catch {
+        return null;
+    }
+}
+function resolveContractDefinitionPath(config, outputDir) {
+    const explicitContractPath = config?.contract.path;
+    if (explicitContractPath && explicitContractPath.trim()) {
+        return resolvePathFromOutput(outputDir, explicitContractPath);
+    }
+    const candidates = CONTRACT_TESTING.CONTRACT_FILENAMES.map((filename) => resolvePathFromOutput(outputDir, filename));
+    const existingCandidate = candidates.find((candidate) => existsSync(candidate));
+    if (existingCandidate) {
+        return existingCandidate;
+    }
+    return candidates[0] ?? resolvePathFromOutput(outputDir, CONTRACT_TESTING.CONTRACT_FILENAMES[0]);
+}
+function buildArtifactContext(cwd, configPath) {
+    const config = loadConfigOrDefaults(cwd, configPath);
+    const outputDir = resolvePathFromCwd(cwd, config?.output.dir ?? CONFIG_DEFAULTS.output.dir);
+    const docsDir = resolvePathFromCwd(cwd, config?.output.docsDir ?? CONFIG_DEFAULTS.output.docsDir);
+    const files = config?.output.files ?? CONFIG_DEFAULTS.output.files;
+    const baselinePathValue = config?.baseline.path ?? PATHS.DEFAULT_BASELINE_FILE;
+    const baselineSaveValue = config?.baseline.savePath ?? baselinePathValue;
+    const baselineCompareValue = config?.baseline.comparePath ?? baselinePathValue;
+    return {
+        cwd,
+        outputDir,
+        docsDir,
+        baselinePath: resolvePathFromOutput(outputDir, baselinePathValue),
+        baselineSavePath: resolvePathFromOutput(outputDir, baselineSaveValue),
+        baselineComparePath: resolveComparePath(cwd, outputDir, baselineCompareValue),
+        contractPath: resolveContractDefinitionPath(config, outputDir),
+        goldenStorePath: getGoldenStorePath(outputDir),
+        files: {
+            checkReport: files.checkReport,
+            exploreReport: files.exploreReport,
+            contractDoc: files.contractDoc,
+            agentsDoc: files.agentsDoc,
+        },
+    };
+}
+function toArtifactSummary(id, label, kind, path) {
+    const exists = existsSync(path);
+    if (!exists) {
+        return {
+            id,
+            label,
+            kind,
+            path,
+            exists: false,
+        };
+    }
+    const stats = statSync(path);
+    return {
+        id,
+        label,
+        kind,
+        path,
+        exists: true,
+        sizeBytes: stats.size,
+        updatedAt: stats.mtime.toISOString(),
+    };
+}
+export function listArtifacts(cwd, configPath) {
+    const context = buildArtifactContext(cwd, configPath);
+    const summaries = [
+        toArtifactSummary('check-report', 'Check JSON Report', 'json', join(context.outputDir, context.files.checkReport)),
+        toArtifactSummary('explore-report', 'Explore JSON Report', 'json', join(context.outputDir, context.files.exploreReport)),
+        toArtifactSummary('contract-doc', 'CONTRACT.md', 'markdown', join(context.docsDir, context.files.contractDoc)),
+        toArtifactSummary('agents-doc', 'AGENTS.md', 'markdown', join(context.docsDir, context.files.agentsDoc)),
+        toArtifactSummary('contract-definition', 'Contract Definition', 'yaml', context.contractPath),
+        toArtifactSummary('golden-store', 'Golden Output Store', 'json', context.goldenStorePath),
+        toArtifactSummary('baseline-save', 'Baseline Save Path', 'json', context.baselineSavePath),
+        toArtifactSummary('baseline-compare', 'Baseline Compare Path', 'json', context.baselineComparePath),
+        toArtifactSummary('baseline-default', 'Baseline Default Path', 'json', context.baselinePath),
+    ];
+    return summaries;
+}
+export function readArtifact(cwd, artifactId, configPath) {
+    const artifact = listArtifacts(cwd, configPath).find((entry) => entry.id === artifactId);
+    if (!artifact) {
+        throw new Error(`Unknown artifact: ${artifactId}`);
+    }
+    if (!artifact.exists) {
+        throw new Error(`Artifact does not exist: ${artifact.path}`);
+    }
+    const raw = readFileSync(artifact.path, 'utf-8');
+    if (artifact.kind !== 'json') {
+        return { artifact, raw };
+    }
+    try {
+        const parsedJson = JSON.parse(raw);
+        return { artifact, raw, parsedJson };
+    }
+    catch (error) {
+        return {
+            artifact,
+            raw,
+            parseError: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function asRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
+function getArrayLength(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    return value.length;
+}
+export function getArtifactOverview(cwd, configPath) {
+    const artifacts = listArtifacts(cwd, configPath);
+    const checkArtifact = artifacts.find((artifact) => artifact.id === 'check-report');
+    const exploreArtifact = artifacts.find((artifact) => artifact.id === 'explore-report');
+    const goldenArtifact = artifacts.find((artifact) => artifact.id === 'golden-store');
+    const contractArtifact = artifacts.find((artifact) => artifact.id === 'contract-definition');
+    const check = checkArtifact
+        ? summarizeInterviewArtifact(cwd, checkArtifact, configPath)
+        : { available: false, path: '' };
+    const explore = exploreArtifact
+        ? summarizeInterviewArtifact(cwd, exploreArtifact, configPath)
+        : { available: false, path: '' };
+    const golden = goldenArtifact
+        ? summarizeGoldenArtifact(cwd, goldenArtifact, configPath)
+        : { available: false, path: '' };
+    return {
+        check,
+        explore,
+        golden,
+        contract: {
+            available: Boolean(contractArtifact?.exists),
+            path: contractArtifact?.path ?? '',
+        },
+    };
+}
+function summarizeInterviewArtifact(cwd, artifact, configPath) {
+    if (!artifact.exists) {
+        return {
+            available: false,
+            path: artifact.path,
+        };
+    }
+    try {
+        const report = readArtifact(cwd, artifact.id, configPath);
+        const parsed = asRecord(report.parsedJson);
+        if (!parsed) {
+            return {
+                available: true,
+                path: artifact.path,
+            };
+        }
+        const discovery = asRecord(parsed.discovery);
+        const metadata = asRecord(parsed.metadata);
+        return {
+            available: true,
+            path: artifact.path,
+            summary: typeof parsed.summary === 'string' ? parsed.summary : undefined,
+            toolCount: getArrayLength(discovery?.tools),
+            promptCount: getArrayLength(discovery?.prompts),
+            resourceCount: getArrayLength(discovery?.resources),
+            durationMs: typeof metadata?.durationMs === 'number' ? metadata.durationMs : undefined,
+            errorCount: typeof metadata?.errorCount === 'number' ? metadata.errorCount : undefined,
+        };
+    }
+    catch {
+        return {
+            available: true,
+            path: artifact.path,
+        };
+    }
+}
+function summarizeGoldenArtifact(cwd, artifact, configPath) {
+    if (!artifact.exists) {
+        return {
+            available: false,
+            path: artifact.path,
+        };
+    }
+    try {
+        const report = readArtifact(cwd, artifact.id, configPath);
+        const parsed = asRecord(report.parsedJson);
+        return {
+            available: true,
+            path: artifact.path,
+            outputCount: getArrayLength(parsed?.outputs),
+            lastUpdated: typeof parsed?.lastUpdated === 'string' ? parsed.lastUpdated : undefined,
+        };
+    }
+    catch {
+        return {
+            available: true,
+            path: artifact.path,
+        };
+    }
+}
+//# sourceMappingURL=artifact-index.js.map