@orangepro/orangepro-mcp 0.1.0

package/dist/local/viz/payload.js

@@ -0,0 +1,525 @@
+import { behaviorNodes, isDenominatorEligible } from "../graph/factories.js";
+import { structurallyUnconfirmable } from "../graph/confirmable.js";
+import { languageOf } from "../analyze/classify.js";
+import { LEDGER_SCHEMA_VERSION } from "../ledger.js";
+import { buildRtm } from "../rtm.js";
+// What counts as a behavior comes ONLY from the canonical helpers
+// (factories.behaviorNodes over ontology.BEHAVIOR_KINDS) — a duplicated local
+// kind set lived here once and could silently drift from score's definition.
+const DEFAULT_KINDS = [
+    "TenantStub",
+    "Requirement",
+    "UserFlow",
+    "BusinessRule",
+    "AcceptanceCriterion",
+    "Service",
+    "Endpoint",
+    "Incident",
+    "Framework",
+    "Package"
+];
+function tally(items) {
+    const m = new Map();
+    for (const k of items)
+        m.set(k, (m.get(k) ?? 0) + 1);
+    return [...m.entries()].map(([kind, count]) => ({ kind, count })).sort((a, b) => b.count - a.count);
+}
+function behaviorEvidence(graph, externalId) {
+    const hard = graph.edges.some((e) => (e.relationship_type === "TESTED_BY" || e.relationship_type === "COVERS") &&
+        (e.from_external_id === externalId || e.to_external_id === externalId));
+    if (hard)
+        return "covered";
+    const weak = graph.candidate_edges.some((e) => (e.relationship_type === "MAY_BE_TESTED_BY" || e.relationship_type === "MAY_COVER") &&
+        (e.from_external_id === externalId || e.to_external_id === externalId));
+    return weak ? "weak" : "none";
+}
+/** First path segment of a provenance ref / source path (the "area"). */
+function areaOf(sourceRefOrPath) {
+    if (!sourceRefOrPath)
+        return "core";
+    const cleaned = sourceRefOrPath.replace(/^[./]+/, "").split(/[#?]/)[0];
+    const first = cleaned.split(/[\\/]/).filter(Boolean)[0];
+    return first || "core";
+}
+function cleanPathParts(sourceRefOrPath) {
+    if (!sourceRefOrPath)
+        return [];
+    return sourceRefOrPath.replace(/^[./]+/, "").split(/[#?]/)[0].split(/[\\/]/).filter(Boolean);
+}
+function parentDir(parts) {
+    return parts.length > 1 ? parts[parts.length - 2] : parts[0] || "core";
+}
+function codeAreaOf(sourceRefOrPath) {
+    const parts = cleanPathParts(sourceRefOrPath);
+    if (parts.length === 0)
+        return "core";
+    const language = languageOf(sourceRefOrPath ?? "");
+    if (language === "java" || language === "kotlin") {
+        const srcIdx = parts.findIndex((p, i) => p === "src" && (parts[i + 1] === "main" || parts[i + 1] === "test"));
+        if (srcIdx >= 0 && parts[srcIdx + 2] && ["java", "kotlin"].includes(parts[srcIdx + 2]))
+            return parentDir(parts.slice(srcIdx + 3));
+        return parentDir(parts);
+    }
+    if (language === "python") {
+        if (["src", "app", "mealie"].includes(parts[0]) && parts.length > 2)
+            return parts.slice(1, 3).join("/");
+        return parts.length > 2 ? parts.slice(0, 2).join("/") : parentDir(parts);
+    }
+    if (language === "go") {
+        if (parts[0] === "server" && parts[1] === "channels" && parts[2])
+            return `server/${parts[2]}`;
+        return parts.length > 2 ? parts.slice(0, 2).join("/") : parentDir(parts);
+    }
+    if (language === "typescript" || language === "javascript") {
+        if (parts[0] === "webapp" && parts[1] === "channels" && parts[2] === "src" && parts[3])
+            return `webapp/${parts[3]}`;
+        if (parts[0] === "frontend" && parts[1] === "app" && parts[2])
+            return `frontend/${parts[2]}`;
+        return parts.length > 2 ? parts.slice(0, 2).join("/") : parentDir(parts);
+    }
+    return parts.length > 2 ? parts.slice(0, 2).join("/") : parentDir(parts);
+}
+/**
+ * 4-state coverage for a UserFlow (precedence: confirmed > nsc > inferred > none):
+ *   confirmed = hard TESTED_BY/COVERS edge; not_structurally_confirmable = no hard
+ *   edge but all tests are e2e/api; inferred = weak candidate edge; none = neither.
+ */
+function flowCoverage(graph, externalId, nsc) {
+    const ev = behaviorEvidence(graph, externalId);
+    if (ev === "covered")
+        return "confirmed";
+    if (nsc.has(externalId))
+        return "not_structurally_confirmable";
+    if (ev === "weak")
+        return "inferred";
+    return "none";
+}
+/** TestCase external_ids weakly linked to this flow via MAY_BE_TESTED_BY / MAY_COVER (capped). */
+function flowTestIds(graph, externalId) {
+    return flowTestLinks(graph, externalId)
+        .filter((l) => l.status === "possible")
+        .map((l) => l.to)
+        .slice(0, 2);
+}
+function flowTestLinks(graph, externalId) {
+    const nodeById = new Map(graph.nodes.map((n) => [n.external_id, n]));
+    const links = new Map();
+    for (const e of graph.candidate_edges) {
+        if (e.relationship_type !== "MAY_BE_TESTED_BY" && e.relationship_type !== "MAY_COVER")
+            continue;
+        let other;
+        if (e.from_external_id === externalId)
+            other = e.to_external_id;
+        else if (e.to_external_id === externalId)
+            other = e.from_external_id;
+        if (!other || links.has(other))
+            continue;
+        const node = nodeById.get(other);
+        if (node?.kind === "TestCase") {
+            links.set(other, {
+                from: externalId,
+                to: other,
+                status: "possible",
+                label: "Possible test link",
+                confidence: e.confidence
+            });
+        }
+    }
+    for (const e of graph.edges) {
+        if (e.relationship_type !== "TESTED_BY" && e.relationship_type !== "COVERS")
+            continue;
+        let testId;
+        if (e.from_external_id === externalId)
+            testId = e.to_external_id;
+        else if (e.to_external_id === externalId)
+            testId = e.from_external_id;
+        if (!testId || nodeById.get(testId)?.kind !== "TestCase")
+            continue;
+        links.set(testId, {
+            from: externalId,
+            to: testId,
+            status: "confirmed",
+            label: "Static test link",
+            confidence: e.confidence ?? 1,
+            ...(typeof e.last_verified === "number" ? { last_verified: e.last_verified } : {})
+        });
+    }
+    return [...links.values()].sort((a, b) => (a.status === b.status ? a.to.localeCompare(b.to) : a.status === "confirmed" ? -1 : 1));
+}
+function nodeFileRef(n) {
+    if (typeof n.properties.file === "string")
+        return n.properties.file;
+    if (typeof n.provenance?.source_ref === "string")
+        return n.provenance.source_ref;
+    return n.external_id.replace(/^sym:/, "").split("#")[0];
+}
+function symbolProofLinks(graph) {
+    const nodeById = new Map(graph.nodes.map((n) => [n.external_id, n]));
+    const links = new Map();
+    for (const e of graph.edges) {
+        if (e.relationship_type !== "TESTED_BY" && e.relationship_type !== "COVERS")
+            continue;
+        const from = nodeById.get(e.from_external_id);
+        const to = nodeById.get(e.to_external_id);
+        let symbol = from?.kind === "CodeSymbol" ? from : to?.kind === "CodeSymbol" ? to : undefined;
+        let test = from?.kind === "TestCase" ? from : to?.kind === "TestCase" ? to : undefined;
+        if (!symbol || !test || symbol.denominator_eligible === false)
+            continue;
+        const key = `${symbol.external_id}|${test.external_id}`;
+        links.set(key, {
+            from: symbol.external_id,
+            to: test.external_id,
+            symbol_label: symbol.title || symbol.external_id,
+            test_label: test.title || test.external_id,
+            area: areaOf(nodeFileRef(symbol)),
+            confidence: e.confidence ?? 1,
+            ...(typeof e.last_verified === "number" ? { last_verified: e.last_verified } : {})
+        });
+    }
+    return [...links.values()].sort((a, b) => a.area.localeCompare(b.area) || a.from.localeCompare(b.from) || a.to.localeCompare(b.to));
+}
+function behaviorHasAc(graph, externalId) {
+    if (graph.edges.some((e) => e.relationship_type === "HAS_ACCEPTANCE_CRITERION" && e.from_external_id === externalId)) {
+        return true;
+    }
+    const node = graph.nodes.find((n) => n.external_id === externalId);
+    const inline = node?.properties.acceptance_criteria;
+    return Array.isArray(inline) ? inline.length > 0 : Boolean(inline);
+}
+function languageLabel(language) {
+    const labels = {
+        typescript: "TypeScript/JavaScript",
+        javascript: "TypeScript/JavaScript",
+        python: "Python",
+        go: "Go",
+        java: "Java",
+        ruby: "Ruby",
+        kotlin: "Kotlin",
+        rust: "Rust",
+        php: "PHP",
+        csharp: "C#",
+        swift: "Swift",
+        c: "C",
+        cpp: "C++"
+    };
+    return labels[language] ?? language;
+}
+function emptyLedger() {
+    return { schema_version: LEDGER_SCHEMA_VERSION, records: [] };
+}
+function publicRowsById(graph, ledger) {
+    return new Map(buildRtm(graph, ledger ?? emptyLedger()).rows.map((row) => [row.behavior_id, row]));
+}
+function eligibleCodeSymbols(graph) {
+    return graph.nodes.filter((n) => n.kind === "CodeSymbol" && isDenominatorEligible(n));
+}
+function languageTiers(graph, ledger) {
+    const publicRows = publicRowsById(graph, ledger);
+    const rows = new Map();
+    for (const n of eligibleCodeSymbols(graph)) {
+        const file = nodeFileRef(n) ?? "";
+        const publicRow = publicRows.get(n.external_id);
+        const language = languageLabel(languageOf(file));
+        let row = rows.get(language);
+        if (!row) {
+            row = { language, total: 0, proven: 0, runtime_covered: 0, associated: 0, unlinked: 0, proven_pct: 0, runtime_pct: 0, associated_pct: 0 };
+            rows.set(language, row);
+        }
+        row.total++;
+        if (publicRow?.evidence_tier === "proven")
+            row.proven++;
+        else if (publicRow?.evidence_tier === "runtime")
+            row.runtime_covered++;
+        else if (publicRow?.evidence_tier === "associated")
+            row.associated++;
+        else
+            row.unlinked++;
+    }
+    return [...rows.values()]
+        .map((r) => ({
+        ...r,
+        proven_pct: r.total > 0 ? (r.proven / r.total) * 100 : 0,
+        runtime_pct: r.total > 0 ? (r.runtime_covered / r.total) * 100 : 0,
+        associated_pct: r.total > 0 ? (r.associated / r.total) * 100 : 0
+    }))
+        .sort((a, b) => b.total - a.total || a.language.localeCompare(b.language));
+}
+function codeAreaSummary(graph, ledger) {
+    const publicRows = publicRowsById(graph, ledger);
+    const areaMap = new Map();
+    for (const n of eligibleCodeSymbols(graph)) {
+        const file = nodeFileRef(n) ?? "";
+        const publicRow = publicRows.get(n.external_id);
+        const area = codeAreaOf(file);
+        let a = areaMap.get(area);
+        if (!a) {
+            a = { total: 0, confirmed: 0, runtime_covered: 0, inferred: 0, none: 0, noLinkSamples: [], associatedSamples: [] };
+            areaMap.set(area, a);
+        }
+        a.total++;
+        if (publicRow?.evidence_tier === "proven") {
+            a.confirmed++;
+        }
+        else if (publicRow?.evidence_tier === "runtime") {
+            a.runtime_covered++;
+        }
+        else {
+            const sample = { title: n.title || n.external_id, file, status: "none" };
+            if (publicRow?.evidence_tier === "associated") {
+                a.inferred++;
+                a.associatedSamples.push({ ...sample, status: "associated" });
+            }
+            else {
+                a.none++;
+                a.noLinkSamples.push(sample);
+            }
+        }
+    }
+    return [...areaMap.entries()]
+        .map(([area, a]) => ({
+        area,
+        total: a.total,
+        confirmed: a.confirmed,
+        runtime_covered: a.runtime_covered,
+        inferred: a.inferred,
+        not_structurally_confirmable: 0,
+        none: a.none,
+        confirmed_pct: a.total > 0 ? (a.confirmed / a.total) * 100 : 0,
+        sample_gaps: [...a.noLinkSamples, ...a.associatedSamples].slice(0, 6)
+    }))
+        .sort((x, y) => y.total - x.total || x.area.localeCompare(y.area));
+}
+function codeBehaviorRows(graph, ledger) {
+    const publicRows = publicRowsById(graph, ledger);
+    return eligibleCodeSymbols(graph)
+        .map((n) => {
+        const file = nodeFileRef(n) ?? "";
+        const tier = publicRows.get(n.external_id)?.evidence_tier;
+        const evidence = tier === "proven"
+            ? "proven"
+            : tier === "runtime"
+                ? "runtime"
+                : tier === "associated"
+                    ? "associated"
+                    : "none";
+        return {
+            id: n.external_id,
+            title: n.title || n.external_id,
+            file,
+            area: codeAreaOf(file),
+            language: languageLabel(languageOf(file)),
+            evidence
+        };
+    })
+        .sort((a, b) => {
+        const rank = (x) => (x.evidence === "none" ? 0 : x.evidence === "associated" ? 1 : x.evidence === "runtime" ? 2 : 3);
+        return rank(a) - rank(b) || a.area.localeCompare(b.area) || a.file.localeCompare(b.file) || a.title.localeCompare(b.title);
+    });
+}
+function staticFlowRows(graph) {
+    const flows = graph.analysis?.flows?.flows ?? [];
+    const items = flows.slice(0, 100).map((flow) => ({
+        id: flow.id,
+        entry_id: flow.entry_point.external_id,
+        entry_title: flow.entry_point.title || flow.entry_point.external_id,
+        entry_kind: flow.entry_point.kind,
+        terminal: flow.terminal,
+        depth: flow.depth,
+        tier: flow.flow_tier,
+        truncated: flow.truncated === true,
+        hops: flow.hops.map((h) => ({
+            from: h.from,
+            to: h.to,
+            strength: h.evidence_strength,
+            ...(h.resolution ? { resolution: h.resolution } : {})
+        }))
+    }));
+    return {
+        total: graph.analysis?.flows?.total_flows ?? flows.length,
+        hard_reachable: graph.analysis?.flows?.by_tier["hard: reachable"] ?? flows.filter((f) => f.flow_tier === "hard: reachable").length,
+        framework_derived_reachable: graph.analysis?.flows?.by_tier["framework-derived: reachable"] ?? flows.filter((f) => f.flow_tier === "framework-derived: reachable").length,
+        truncated: graph.analysis?.flows?.truncated_flows ?? flows.filter((f) => f.truncated === true).length,
+        items
+    };
+}
+/** Build the gap-first view model (heatmap / connectivity / flows). */
+function buildGap(graph, ledger) {
+    const nsc = structurallyUnconfirmable(graph);
+    const publicRtm = buildRtm(graph, ledger ?? emptyLedger());
+    const flows = graph.nodes
+        .filter((n) => n.kind === "UserFlow")
+        .map((n) => {
+        const ref = n.provenance?.source_ref;
+        const propArea = typeof n.properties.area === "string" ? n.properties.area : undefined;
+        const area = ref ? areaOf(ref) : propArea || "core";
+        const behaviors = Array.isArray(n.properties.example_behaviors)
+            ? n.properties.example_behaviors.filter((b) => typeof b === "string").slice(0, 3)
+            : [];
+        const coverage = flowCoverage(graph, n.external_id, nsc);
+        const test_links = flowTestLinks(graph, n.external_id);
+        return {
+            id: n.external_id,
+            title: n.title || n.external_id,
+            area,
+            coverage,
+            has_test: coverage === "confirmed",
+            ...(coverage === "not_structurally_confirmable" ? { defer_reason: nsc.get(n.external_id) } : {}),
+            test_ids: flowTestIds(graph, n.external_id),
+            test_links,
+            confidence: n.confidence,
+            behaviors
+        };
+    });
+    const userflows = flows.length;
+    const confirmed = flows.filter((f) => f.coverage === "confirmed").length;
+    const inferred = flows.filter((f) => f.coverage === "inferred").length;
+    const notStructurallyConfirmable = flows.filter((f) => f.coverage === "not_structurally_confirmable").length;
+    const none = flows.filter((f) => f.coverage === "none").length;
+    // confirmed_pct EXCLUDES nsc: e2e/api behaviors never dilute the structural %.
+    const confirmableTotal = confirmed + inferred + none;
+    const confirmed_pct = confirmableTotal > 0 ? (confirmed / confirmableTotal) * 100 : 0;
+    const area_summary = codeAreaSummary(graph, ledger);
+    const testCaseNodes = graph.nodes.filter((n) => n.kind === "TestCase");
+    const testcases_sample = testCaseNodes.slice(0, 60).map((n) => ({
+        id: n.external_id,
+        title: n.title || n.external_id,
+        test_names: Array.isArray(n.properties.test_names)
+            ? n.properties.test_names.filter((t) => typeof t === "string").slice(0, 3)
+            : [],
+        test_layer: typeof n.properties.test_layer === "string" ? n.properties.test_layer : "unknown"
+    }));
+    const symbol_test_links = symbolProofLinks(graph);
+    const services = [...new Set([...flows.map((f) => f.area), ...symbol_test_links.map((l) => l.area)])].map((name) => ({
+        id: `area:${name}`,
+        title: name,
+        area: name
+    }));
+    // Headline Proven is computed over the public denominator behaviors from the
+    // same RTM gate as COVERAGE_REPORT.md: dynamic targeted proof only.
+    return {
+        workspace: graph.workspace.name,
+        stats: {
+            userflows,
+            testcases: testCaseNodes.length,
+            confirmed,
+            inferred,
+            not_structurally_confirmable: notStructurallyConfirmable,
+            none,
+            confirmable_total: confirmableTotal,
+            confirmed_pct,
+            coverage_pct: confirmed_pct,
+            behavior_confirmed: publicRtm.summary.proven,
+            behavior_total: publicRtm.summary.total,
+            behavior_confirmed_pct: publicRtm.summary.coverage_pct
+        },
+        area_summary,
+        language_tiers: languageTiers(graph, ledger),
+        code_behaviors: codeBehaviorRows(graph, ledger),
+        static_flows: staticFlowRows(graph),
+        all_userflows: flows,
+        symbol_test_links,
+        testcases_sample,
+        services,
+        ...(graph.analysis?.not_analyzed_due_to_budget
+            ? {
+                partial_scan: {
+                    files_not_analyzed: graph.analysis.not_analyzed_due_to_budget.files_not_analyzed,
+                    budget_ms: graph.analysis.not_analyzed_due_to_budget.budget_ms
+                }
+            }
+            : {}),
+        ...(graph.analysis?.confirmed_coverage && graph.analysis.confirmed_coverage.skipped_files_budget > 0
+            ? {
+                proof_limited: {
+                    skipped_files_budget: graph.analysis.confirmed_coverage.skipped_files_budget,
+                    ...(graph.analysis.confirmed_coverage.scoped_by_risk ? { scoped_by_risk: graph.analysis.confirmed_coverage.scoped_by_risk } : {})
+                }
+            }
+            : {})
+    };
+}
+export function buildVizPayload(graph, score, ledger) {
+    const behaviors = behaviorNodes(graph);
+    const behaviorMeta = new Map();
+    let gaps = 0;
+    for (const b of behaviors) {
+        const ac = behaviorHasAc(graph, b.external_id);
+        const evidence = behaviorEvidence(graph, b.external_id);
+        behaviorMeta.set(b.external_id, { ac, evidence });
+        if (!ac || evidence !== "covered")
+            gaps++;
+    }
+    const nodes = graph.nodes.map((n) => {
+        const node = {
+            id: n.external_id,
+            label: (n.title || n.external_id).slice(0, 80),
+            kind: n.kind,
+            strength: n.evidence_strength,
+            confidence: n.confidence,
+            ref: n.provenance?.source_ref
+        };
+        const bm = behaviorMeta.get(n.external_id);
+        if (bm) {
+            node.ac = bm.ac;
+            node.evidence = bm.evidence;
+        }
+        return node;
+    });
+    const edges = [
+        ...graph.edges.map((e) => ({
+            from: e.from_external_id,
+            to: e.to_external_id,
+            kind: e.relationship_type,
+            weak: e.evidence_strength === "framework-derived",
+            strength: e.evidence_strength
+        })),
+        ...graph.candidate_edges.map((e) => ({
+            from: e.from_external_id,
+            to: e.to_external_id,
+            kind: e.relationship_type,
+            weak: true,
+            confidence: e.confidence
+        }))
+    ];
+    const strength = {};
+    for (const n of graph.nodes)
+        strength[n.evidence_strength] = (strength[n.evidence_strength] ?? 0) + 1;
+    const frameworks = graph.nodes.filter((n) => n.kind === "Framework").map((n) => n.title || n.external_id);
+    const sources = graph.sources.map((s) => ({ system: s.source_system, name: s.display_name }));
+    const generatedItems = graph.generated_tests.map((t) => ({
+        title: t.title,
+        entity_ids: t.grounding.entity_ids,
+        bucket: t.bucket
+    }));
+    const generatedByBucket = tally(graph.generated_tests.map((t) => t.bucket).filter((b) => b !== undefined)).map((x) => ({ bucket: x.kind, count: x.count }));
+    return {
+        meta: {
+            workspace: graph.workspace.name,
+            created_at: graph.updated_at,
+            source_upload_policy: graph.workspace.source_upload_policy,
+            score: {
+                overall: score.overall,
+                band: score.band,
+                breakdown: score.breakdown,
+                missing_evidence: score.missing_evidence
+            },
+            analysis: graph.analysis ?? null,
+            counts: {
+                nodes: graph.nodes.length,
+                edges: graph.edges.length,
+                candidates: graph.candidate_edges.length,
+                nodesByKind: tally(graph.nodes.map((n) => n.kind)),
+                edgesByKind: tally([...graph.edges, ...graph.candidate_edges].map((e) => e.relationship_type)),
+                strength
+            },
+            frameworks,
+            sources,
+            generated: { count: graph.generated_tests.length, byBucket: generatedByBucket, items: generatedItems },
+            gaps
+        },
+        nodes,
+        edges,
+        defaultKinds: DEFAULT_KINDS,
+        gap: buildGap(graph, ledger)
+    };
+}

package/dist/local/workspace.js

@@ -0,0 +1,99 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { LOCAL_GRAPH_SCHEMA_VERSION } from "./graph/ontology.js";
+import { defaultPrivacySettings } from "./localConfig.js";
+export const WORKSPACE_DIR = ".orangepro";
+export const GRAPH_FILE = "graph.json";
+export const CONFIG_FILE = "config.json";
+export function workspacePaths(root) {
+    const absRoot = resolve(root);
+    const dir = join(absRoot, WORKSPACE_DIR);
+    return {
+        root: absRoot,
+        dir,
+        graphPath: join(dir, GRAPH_FILE),
+        configPath: join(dir, CONFIG_FILE)
+    };
+}
+export function workspaceInitialized(root) {
+    return existsSync(workspacePaths(root).configPath);
+}
+export function graphExists(root) {
+    return existsSync(workspacePaths(root).graphPath);
+}
+const ORANGEPROIGNORE_TEMPLATE = `# .orangeproignore — paths the OrangePro local proof kit should never read.
+# Same spirit as .gitignore. Secrets and large assets are excluded by default.
+*.env
+*.pem
+*.key
+secrets/
+*evidence-pack.json
+*evidence-pack.md
+
+# Product-denominator defaults: example/demo apps are useful references, but
+# they usually should not count as product behavior coverage.
+examples/
+example/
+demos/
+demo/
+samples/
+sample/
+docs/examples/
+docs/demo/
+docs/demos/
+`;
+export function initWorkspace(root, now) {
+    const paths = workspacePaths(root);
+    mkdirSync(paths.dir, { recursive: true });
+    const config = {
+        workspace_name: deriveWorkspaceName(paths.root),
+        created_at: now,
+        local_only: true,
+        privacy: defaultPrivacySettings()
+    };
+    if (!existsSync(paths.configPath)) {
+        writeJson(paths.configPath, config);
+    }
+    const ignorePath = join(paths.root, ".orangeproignore");
+    if (!existsSync(ignorePath)) {
+        writeFileSync(ignorePath, ORANGEPROIGNORE_TEMPLATE, "utf8");
+    }
+    return { paths, config: loadConfig(paths) };
+}
+export function loadConfig(paths) {
+    if (!existsSync(paths.configPath)) {
+        return {
+            workspace_name: deriveWorkspaceName(paths.root),
+            created_at: "",
+            local_only: true,
+            privacy: defaultPrivacySettings()
+        };
+    }
+    return JSON.parse(readFileSync(paths.configPath, "utf8"));
+}
+export function saveConfig(paths, config) {
+    writeJson(paths.configPath, config);
+}
+export function loadGraph(graphPath) {
+    if (!existsSync(graphPath)) {
+        throw new Error(`No graph found at ${graphPath}. Run \`opro analyze .\` first.`);
+    }
+    const graph = JSON.parse(readFileSync(graphPath, "utf8"));
+    if (graph.schema_version !== LOCAL_GRAPH_SCHEMA_VERSION) {
+        // Force-rebuild on any schema mismatch: the graph is fully derived from the
+        // repo, so rebuilding loses nothing and silently consuming an old schema
+        // (e.g. v0 without denominator fields) would corrupt coverage math.
+        throw new Error(`Graph schema mismatch: found ${graph.schema_version ?? "unknown"}, expected ${LOCAL_GRAPH_SCHEMA_VERSION}. ` +
+            "Run `opro analyze .` to rebuild — no data loss (the graph is derived from your repo).");
+    }
+    return graph;
+}
+export function saveGraph(graphPath, graph) {
+    writeJson(graphPath, graph);
+}
+export function deriveWorkspaceName(root) {
+    return resolve(root).split(/[\\/]/).filter(Boolean).pop() || "workspace";
+}
+function writeJson(path, value) {
+    writeFileSync(path, JSON.stringify(value, null, 2) + "\n", "utf8");
+}