@software-dlc/cli 0.157.2

package/dist/local/workspace-claim-status.js

@@ -0,0 +1,721 @@
+import { execFile } from 'node:child_process';
+import { behindReferences } from './workspace-evidence-status.js';
+/**
+ * `sdlc workspace status`: each node's claim status in a view
+ * (docs/specs/graph-claim-status.md, Statuses and Reading status).
+ *
+ *   unrecorded   no source reference says where its code is
+ *   planned      a pending claim merged under the `plan` gate
+ *   designed     a pending claim merged under the `design` gate
+ *   implemented  it has a source reference; `environment` is the furthest
+ *                one, in the order given, whose Git ref holds every commit
+ *                its references were recorded at
+ *   released     that environment is the last one given
+ *
+ * A node that cites no code (no source reference, and a type not in
+ * `cites_code`) follows the nodes that realize it: it takes the lowest status
+ * among them and names the ones that hold it back. A reference that no longer
+ * matches the code marks the node stale and leaves its status alone. The
+ * status is derived and never stored. Graph only, read only: Git is the
+ * caller's, through `ClaimStatusGit`.
+ */
+export const CLAIM_STATUSES = [
+    'unrecorded',
+    'planned',
+    'designed',
+    'implemented',
+    'released'
+];
+export const CLAIM_STATUS_VIEWS = ['planned', 'built', 'released'];
+const SOURCE_PROVIDER = 'sdlc.source_code';
+const HELD_SHOWN = 5;
+const SELECTOR = /^L(\d+)-L(\d+)$/;
+const IDENTIFIER = /[A-Za-z_$][\w$]*/g;
+const CODE_SUFFIXES = [
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.mjs',
+    '.cjs',
+    '.py',
+    '.sql'
+];
+const PARAMETERS_SCANNED = 4000;
+const MODIFIERS = '(?:export|default|async|static|public|private|protected|readonly|get|set|override)';
+const declaration = (name) => new RegExp(`\\b(?:function\\*?|class|const|let|var|def|interface|type|enum|namespace|table|view|policy|trigger` +
+    `|index|procedure)\\s+(?:if\\s+not\\s+exists\\s+)?(?:[\\w$"]+\\.)?"?${name}"?(?![\\w$])` +
+    `|(?<![\\w$.])(?<!:)(?<!:\\s)${name}\\s*(?::[^=;,\\n]+)?=(?![=>])` +
+    `|^\\s*(?:${MODIFIERS}\\s+)*${name}\\s*(?:<[^>\\n]*>)?\\([^)\\n]*\\)\\s*(?::[^{\\n]+)?\\{` +
+    `|^\\s*(?:${MODIFIERS}\\s+)+${name}\\s*(?:<[^>\\n]*>)?\\(` +
+    `|^\\s*["']?${name}["']?\\s*:` +
+    // A CommonJS export: exports.handler = … or module.exports.handler = ….
+    `|\\b(?:module\\.)?exports\\.${name}\\s*=(?![=>])`, 'im');
+const exported = (name) => new RegExp(`\\bexport\\s*(?:type\\s*)?\\{[^}]*\\bas\\s+${name}\\s*[,}]` +
+    `|\\bexport\\s*(?:type\\s*)?\\{(?:[^}]*[\\s,])?${name}\\s*(?:,[^}]*)?\\}\\s*from\\b`, 'im');
+const method = (name) => new RegExp(`^[ \\t]*${name}\\s*(?:<[^>\\n]*>)?\\(`, 'gim');
+const FLOW = ['start', 'process', 'decision', 'end'];
+/** The relations that count as realizing, for each node type that cites no code. */
+const REALIZED_BY = {
+    story: [['targets', 'implements'], ['sources', 'implements'], ['equivalent']],
+    ...Object.fromEntries(FLOW.map((kind) => [
+        kind,
+        [['targets', 'implements'], ['parent']]
+    ])),
+    goal: [['targets', 'depends_on']],
+    feature: [['children', 'story']],
+    product: [['children', 'feature']],
+    document: [['targets', 'describes']],
+    system: [
+        ['children', null],
+        ['targets', 'implements']
+    ],
+    ...Object.fromEntries(['context', 'container', 'website', 'api_gateway', 'database'].map((kind) => [kind, [['children', null]]]))
+};
+const UNRECORDED = {
+    status: 'unrecorded',
+    environment: null,
+    established_by: null,
+    stale: []
+};
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+function text(value) {
+    return typeof value === 'string' ? value : null;
+}
+export function parseClaimStatusView(value) {
+    if (value === null || value === undefined)
+        return 'planned';
+    if (CLAIM_STATUS_VIEWS.includes(value))
+        return value;
+    throw new Error(`Unknown view ${value}: use ${CLAIM_STATUS_VIEWS.join(', ')}.`);
+}
+export function parseClaimStatus(value) {
+    if (CLAIM_STATUSES.includes(value))
+        return value;
+    throw new Error(`Unknown status ${value}: use ${CLAIM_STATUSES.join(', ')}.`);
+}
+/** `<key>=<ref>`, in promotion order. */
+export function parseClaimStatusEnvironment(value) {
+    const at = value.indexOf('=');
+    const key = value.slice(0, at).trim();
+    const ref = value.slice(at + 1).trim();
+    if (at < 1 || !key || !ref) {
+        throw new Error(`An environment is <key>=<git ref>, not ${value}.`);
+    }
+    return { key, ref };
+}
+/** A node's source references; a legacy location gives only its path. */
+export function claimReferences(node) {
+    const meta = record(record(record(node).data).meta);
+    const out = [];
+    const references = record(meta.evidence).references;
+    for (const value of Array.isArray(references) ? references : []) {
+        const reference = record(value);
+        const resource = record(reference.resource);
+        const path = text(resource.id);
+        if (reference.provider_key !== SOURCE_PROVIDER ||
+            resource.type !== 'file' ||
+            !path)
+            continue;
+        const anchor = record(reference.anchor);
+        const revision = record(reference.revision);
+        const symbol = anchor.type === 'symbol' ? text(anchor.id) : null;
+        const span = SELECTOR.exec(String((symbol ? anchor.selector : anchor.id) ?? ''));
+        const lines = span
+            ? [Number(span[1]), Number(span[2])]
+            : null;
+        out.push({
+            path,
+            symbol,
+            lines: lines && 1 <= lines[0] && lines[0] <= lines[1] ? lines : null,
+            commit: revision.kind === 'commit' ? text(revision.value) : null,
+            relations: Array.isArray(reference.relations)
+                ? reference.relations.filter((relation) => typeof relation === 'string')
+                : [],
+            legacy: false
+        });
+    }
+    const legacy = record(meta.source_evidence);
+    const locations = [
+        ...(legacy.primary ? [legacy.primary] : []),
+        ...(Array.isArray(legacy.references) ? legacy.references : [])
+    ];
+    for (const location of locations) {
+        const path = text(record(location).path);
+        if (path)
+            out.push({
+                path,
+                symbol: null,
+                lines: null,
+                commit: null,
+                relations: [],
+                legacy: true
+            });
+    }
+    return out;
+}
+function escape(word) {
+    return word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function names(symbol, lines) {
+    const content = lines.join('\n');
+    const words = symbol.match(IDENTIFIER) ?? [symbol];
+    return words.every((word) => new RegExp(`(?<![\\w$])${escape(word)}(?![\\w$])`).test(content));
+}
+function declares(symbol, lines) {
+    const words = symbol.match(IDENTIFIER);
+    if (!words)
+        return names(symbol, lines);
+    const name = escape(words[words.length - 1]);
+    const content = lines.join('\n');
+    if (declaration(name).test(content) || exported(name).test(content))
+        return true;
+    for (const match of content.matchAll(method(name))) {
+        let depth = 1;
+        let at = match.index + match[0].length;
+        const end = Math.min(content.length, match.index + match[0].length + PARAMETERS_SCANNED);
+        while (depth && at < end) {
+            depth += Number(content[at] === '(') - Number(content[at] === ')');
+            at += 1;
+        }
+        if (!depth && /^\s*[{:]/.test(content.slice(at)))
+            return true;
+    }
+    return false;
+}
+/** How a symbol stands in a file's lines: ok, symbol_missing, symbol_undefined, or symbol_moved (outside `span`). */
+export function symbolStatus(symbol, lines, span, defines, path) {
+    const found = defines && CODE_SUFFIXES.some((suffix) => path.endsWith(suffix))
+        ? declares
+        : names;
+    if (!names(symbol, lines))
+        return 'symbol_missing';
+    if (!found(symbol, lines))
+        return 'symbol_undefined';
+    if (span && !found(symbol, lines.slice(span[0] - 1, span[1])))
+        return 'symbol_moved';
+    return 'ok';
+}
+/** (status, detail) of one reference at `commit`; anything but ok and legacy is stale. */
+export async function referenceStatus(git, commit, reference, lines_at = (c, p) => git.lines(c, p)) {
+    const lines = await lines_at(commit, reference.path);
+    if (lines === null)
+        return ['missing_file', `${reference.path} does not exist`];
+    if (reference.legacy)
+        return ['legacy', 'legacy source_evidence; only the file is checked'];
+    const span = reference.lines;
+    if (span && span[1] > lines.length) {
+        return [
+            'past_end',
+            `L${span[0]}-L${span[1]} is past the file's ${lines.length} lines`
+        ];
+    }
+    if (reference.symbol) {
+        const defines = reference.relations.includes('defines');
+        const state = symbolStatus(reference.symbol, lines, span, defines, reference.path);
+        const details = {
+            symbol_missing: `${reference.symbol} is not in ${reference.path}`,
+            symbol_undefined: `${reference.path} mentions ${reference.symbol} but no longer declares it`,
+            symbol_moved: span
+                ? `${reference.symbol} is no longer ${defines ? 'declared ' : ''}in L${span[0]}-L${span[1]}`
+                : null
+        };
+        return [state, details[state] ?? null];
+    }
+    if (span && reference.commit) {
+        if ((await git.resolve(reference.commit)) === null) {
+            return [
+                'revision_unknown',
+                `recorded at ${reference.commit.slice(0, 12)}, which this repository does not have`
+            ];
+        }
+        const before = await lines_at(reference.commit, reference.path);
+        const range = (from) => from.slice(span[0] - 1, span[1]);
+        const was = before === null ? null : range(before);
+        const now = range(lines);
+        if (was === null ||
+            was.length !== now.length ||
+            was.some((line, at) => line !== now[at])) {
+            return [
+                'lines_changed',
+                `L${span[0]}-L${span[1]} changed since ${reference.commit.slice(0, 12)}`
+            ];
+        }
+    }
+    return ['ok', null];
+}
+function claimsOf(graph) {
+    return graph.nodes.map((node) => {
+        const label = record(record(node.data).data).label;
+        return {
+            node: node.id,
+            type: text(node.type),
+            label: typeof label === 'string' ? label : null,
+            parent: text(node.parentId),
+            references: claimReferences(node)
+        };
+    });
+}
+/** {node: the nodes that realize it, sorted} for every node whose type REALIZED_BY lists. */
+export function claimRealizers(graph) {
+    const claims = claimsOf(graph);
+    const kinds = new Map(claims.map((claim) => [claim.node, claim.type]));
+    const push = (map, key, value) => {
+        const list = map.get(key);
+        if (list)
+            list.push(value);
+        else
+            map.set(key, [value]);
+    };
+    const targets = new Map();
+    const origins = new Map();
+    const children = new Map();
+    for (const edge of graph.edges) {
+        const relationship = text(record(record(edge.data).data).type);
+        push(targets, `${edge.source}\u0000${relationship}`, edge.target);
+        push(origins, `${edge.target}\u0000${relationship}`, edge.source);
+    }
+    for (const claim of claims)
+        push(children, claim.parent, claim.node);
+    const paths = new Map((graph.paths ?? []).map((path) => [
+        path.id,
+        path.anchors.map((anchor) => anchor.node_id)
+    ]));
+    const through = new Map();
+    for (const [path, anchors] of paths) {
+        for (const anchor of anchors) {
+            if (!through.has(anchor))
+                through.set(anchor, new Set());
+            through.get(anchor).add(path);
+        }
+    }
+    const equivalent = new Map();
+    for (const relation of graph.path_relations ?? []) {
+        if (relation.relation !== 'equivalent')
+            continue;
+        for (const [one, other] of [
+            [relation.left_path_id, relation.right_path_id],
+            [relation.right_path_id, relation.left_path_id]
+        ]) {
+            if (!equivalent.has(one))
+                equivalent.set(one, new Set());
+            equivalent.get(one).add(other);
+        }
+    }
+    const out = new Map();
+    for (const claim of claims) {
+        const rules = claim.type ? REALIZED_BY[claim.type] : undefined;
+        if (!rules)
+            continue;
+        const found = new Set();
+        for (const rule of rules) {
+            if (rule[0] === 'targets') {
+                for (const other of targets.get(`${claim.node}\u0000${rule[1]}`) ?? [])
+                    found.add(other);
+            }
+            else if (rule[0] === 'sources') {
+                for (const other of origins.get(`${claim.node}\u0000${rule[1]}`) ?? [])
+                    found.add(other);
+            }
+            else if (rule[0] === 'children') {
+                for (const child of children.get(claim.node) ?? []) {
+                    if (rule[1] === null || kinds.get(child) === rule[1])
+                        found.add(child);
+                }
+            }
+            else if (rule[0] === 'parent') {
+                if (claim.parent)
+                    found.add(claim.parent);
+            }
+            else {
+                const steps = (children.get(claim.node) ?? []).filter((child) => FLOW.includes(kinds.get(child) ?? ''));
+                const own = new Set(steps.flatMap((step) => [...(through.get(step) ?? [])]));
+                const others = new Set([...own].flatMap((path) => [...(equivalent.get(path) ?? [])]));
+                for (const path of others) {
+                    if (own.has(path))
+                        continue;
+                    for (const anchor of paths.get(path) ?? []) {
+                        if (![...FLOW, 'goal'].includes(kinds.get(anchor) ?? ''))
+                            found.add(anchor);
+                    }
+                }
+            }
+        }
+        out.set(claim.node, [...found]
+            .filter((other) => kinds.has(other) && other !== claim.node)
+            .sort());
+    }
+    return out;
+}
+function rank(status, environments) {
+    const low = ['unrecorded', 'planned', 'designed'];
+    if (low.includes(status.status))
+        return low.indexOf(status.status);
+    const at = environments.findIndex((environment) => environment.key === status.environment);
+    return at >= 0 ? 4 + at : 3;
+}
+/** Statuses for the nodes in `realized_by` with none of their own: the lowest among their realizers. */
+function following(claims, own, realized_by, environments) {
+    const by_id = new Map(claims.map((claim) => [claim.node, claim]));
+    const settled = new Map();
+    const order = new Map();
+    const low = new Map();
+    const stack = [];
+    // Nodes that realize one another take one status, so a cycle never raises a status.
+    const settle = (group) => {
+        const found = [
+            ...new Set([...group].flatMap((node) => (realized_by.get(node) ?? []).filter((other) => !group.has(other))))
+        ].sort();
+        const ranked = found.map((other) => [other, own.get(other) ?? settled.get(other)]);
+        const ranks = ranked.map(([, status]) => rank(status, environments));
+        const lowest = ranks.length ? Math.min(...ranks) : null;
+        const least = ranked.find(([, status]) => rank(status, environments) === lowest)?.[1] ??
+            null;
+        const held = least === null || least.status === 'released'
+            ? []
+            : ranked
+                .filter(([, status]) => rank(status, environments) === lowest)
+                .map(([other]) => ({
+                node: other,
+                type: by_id.get(other).type,
+                label: by_id.get(other).label
+            }));
+        for (const node of group) {
+            settled.set(node, least === null
+                ? { ...UNRECORDED }
+                : {
+                    status: least.status,
+                    environment: least.environment,
+                    established_by: {
+                        realized_by: realized_by.get(node).length,
+                        held_back: held.length,
+                        held_back_by: held.slice(0, HELD_SHOWN)
+                    },
+                    stale: []
+                });
+        }
+    };
+    // Tarjan's walk, without recursion: a group is settled after every group it follows.
+    const visit = (start) => {
+        const frames = [];
+        const open = (node) => {
+            order.set(node, order.size);
+            low.set(node, order.get(node));
+            stack.push(node);
+            frames.push({ node, next: 0 });
+        };
+        open(start);
+        while (frames.length) {
+            const frame = frames[frames.length - 1];
+            const others = realized_by.get(frame.node) ?? [];
+            if (frame.next < others.length) {
+                const other = others[frame.next++];
+                // A realizer with no status of its own and no rules settles alone, as unrecorded.
+                if (own.has(other) || settled.has(other))
+                    continue;
+                if (!order.has(other)) {
+                    open(other);
+                    continue;
+                }
+                low.set(frame.node, Math.min(low.get(frame.node), low.get(other)));
+                continue;
+            }
+            frames.pop();
+            const parent = frames[frames.length - 1];
+            if (low.get(frame.node) === order.get(frame.node)) {
+                const group = new Set();
+                while (!group.has(frame.node))
+                    group.add(stack.pop());
+                settle(group);
+            }
+            if (parent)
+                low.set(parent.node, Math.min(low.get(parent.node), low.get(frame.node)));
+        }
+    };
+    for (const node of realized_by.keys()) {
+        if (!own.has(node) && !order.has(node))
+            visit(node);
+    }
+    return new Map([...realized_by.keys()]
+        .filter((node) => !own.has(node))
+        .map((node) => [node, settled.get(node)]));
+}
+function gated(rows) {
+    const status = rows.every((row) => row.gate === 'design')
+        ? 'designed'
+        : 'planned';
+    const named = (values) => [
+        ...new Set(values.filter((value) => Boolean(value)))
+    ].sort();
+    return {
+        status,
+        environment: null,
+        stale: [],
+        established_by: {
+            gate: status,
+            gate_commits: named(rows.map((row) => row.gate_commit_id)),
+            work_streams: named(rows.map((row) => row.work_stream_workspace_id))
+        }
+    };
+}
+function counts() {
+    return Object.fromEntries(CLAIM_STATUSES.map((status) => [status, 0]));
+}
+/** Every node's status at `commit`, with the counts; the node list only when asked for. */
+export async function claimStatus(input) {
+    const view = input.view ?? 'planned';
+    const git = input.git;
+    const commit = await git.resolve(input.commit);
+    if (commit === null)
+        throw new Error(`${input.commit} is not a commit in this repository.`);
+    const cache = new Map();
+    const lines_at = (at, path) => {
+        const key = `${at}\u0000${path}`;
+        if (!cache.has(key))
+            cache.set(key, git.lines(at, path));
+        return cache.get(key);
+    };
+    const holds = new Map();
+    const contains = (ref, at) => {
+        const key = `${ref}\u0000${at}`;
+        if (!holds.has(key))
+            holds.set(key, git.isAncestor(at, ref));
+        return holds.get(key);
+    };
+    const claims = claimsOf(input.graph);
+    const by_node = new Map();
+    for (const claim of input.pending) {
+        if (claim.entity_kind !== 'node')
+            continue;
+        by_node.set(claim.entity_id, [
+            ...(by_node.get(claim.entity_id) ?? []),
+            claim
+        ]);
+    }
+    const statusOf = async (claim) => {
+        const references = claim.references;
+        if (!references.length)
+            return { ...UNRECORDED };
+        const stale = [];
+        for (const reference of references) {
+            const [state, detail] = await referenceStatus(git, commit, reference, lines_at);
+            if (state !== 'ok' && state !== 'legacy') {
+                stale.push({
+                    path: reference.path,
+                    status: state,
+                    detail: detail ?? state
+                });
+            }
+        }
+        const commits = [
+            ...new Set(references
+                .map((reference) => reference.commit)
+                .filter((c) => Boolean(c)))
+        ].sort();
+        let environment = null;
+        if (commits.length) {
+            for (const candidate of input.environments) {
+                const all = await Promise.all(commits.map((at) => contains(candidate.ref, at)));
+                if (!all.every(Boolean))
+                    break;
+                environment = candidate;
+            }
+        }
+        const last = input.environments[input.environments.length - 1];
+        const released = Boolean(environment && last && environment.key === last.key);
+        return {
+            status: released ? 'released' : 'implemented',
+            environment: environment?.key ?? null,
+            established_by: {
+                references: references.length,
+                commits,
+                ...(environment ? { ref: environment.ref } : {})
+            },
+            stale
+        };
+    };
+    const referenced = new Map();
+    for (const claim of claims) {
+        if (claim.references.length ||
+            (claim.type && input.cites_code.includes(claim.type))) {
+            referenced.set(claim.node, await statusOf(claim));
+        }
+    }
+    const realized_by = claimRealizers(input.graph);
+    const statuses = (own) => {
+        const follows = following(claims, own, realized_by, input.environments);
+        return new Map(claims.map((claim) => [
+            claim.node,
+            own.get(claim.node) ?? follows.get(claim.node) ?? { ...UNRECORDED }
+        ]));
+    };
+    // As built: each node's records without its pending claim. A node never built realizes nothing.
+    const unbuilt = new Set([...by_node]
+        .filter(([, rows]) => rows.every((row) => row.built_commit_id === null))
+        .map(([node]) => node));
+    const built = statuses(new Map([
+        ...referenced,
+        ...[...unbuilt].map((node) => [node, { ...UNRECORDED }])
+    ]));
+    const current = by_node.size
+        ? statuses(new Map([
+            ...referenced,
+            ...[...by_node].map(([node, rows]) => [node, gated(rows)])
+        ]))
+        : built;
+    const graph_nodes = new Map(input.graph.nodes.map((node) => [node.id, node]));
+    const listed = [];
+    for (const claim of claims) {
+        const rows = by_node.get(claim.node);
+        const never_built = unbuilt.has(claim.node);
+        const as_built = built.get(claim.node);
+        if (view !== 'planned' &&
+            (never_built || (view === 'released' && as_built.status !== 'released'))) {
+            continue;
+        }
+        const status = view === 'planned' ? current.get(claim.node) : as_built;
+        listed.push({
+            node: claim.node,
+            type: claim.type,
+            label: claim.label,
+            follows: !referenced.has(claim.node) && !(rows && view === 'planned'),
+            ...status,
+            behind: behindReferences('node', graph_nodes.get(claim.node)).map((reference) => ({
+                reference_id: reference.reference_id,
+                provider_key: reference.provider_key,
+                resource: reference.resource,
+                claim_object_hash: reference.claim_object_hash
+            })),
+            ...(rows && view === 'planned'
+                ? {
+                    built_as: never_built
+                        ? null
+                        : { status: as_built.status, environment: as_built.environment }
+                }
+                : {})
+        });
+    }
+    const by_status = counts();
+    const by_environment = {};
+    const by_type = {};
+    for (const node of listed) {
+        by_status[node.status] += 1;
+        if (node.status === 'implemented') {
+            const key = node.environment ?? 'none';
+            by_environment[key] = (by_environment[key] ?? 0) + 1;
+        }
+        const kind = node.type ?? '(no type)';
+        by_type[kind] ??= counts();
+        by_type[kind][node.status] += 1;
+    }
+    const followers = listed.filter((node) => node.follows);
+    const follower_counts = counts();
+    for (const node of followers)
+        follower_counts[node.status] += 1;
+    const other_claims = {};
+    for (const claim of input.pending) {
+        if (claim.entity_kind !== 'node') {
+            other_claims[claim.entity_kind] =
+                (other_claims[claim.entity_kind] ?? 0) + 1;
+        }
+    }
+    const asked = Boolean(input.nodes?.length || input.status || input.stale_only || input.behind_only);
+    const wanted = new Set(input.nodes ?? []);
+    const sum = (value) => Object.values(value).reduce((total, n) => total + n, 0);
+    return {
+        version: 1,
+        view,
+        workspace_id: input.workspace_id,
+        graph_commit_id: input.graph_commit_id,
+        commit,
+        environments: await Promise.all(input.environments.map(async (environment) => ({
+            ...environment,
+            resolved: (await git.resolve(environment.ref)) !== null
+        }))),
+        cites_code: [...input.cites_code],
+        pending: {
+            nodes: by_node.size,
+            marked_for_removal: [...by_node]
+                .filter(([, rows]) => rows.some((row) => row.change === 'removal'))
+                .map(([node]) => node)
+                .sort(),
+            other_claims
+        },
+        nodes: listed.length,
+        by_status,
+        implemented_by_environment: by_environment,
+        stale_nodes: listed.filter((node) => node.stale.length).length,
+        behind_nodes: listed.filter((node) => node.behind.length).length,
+        following: {
+            nodes: followers.length,
+            by_status: follower_counts,
+            unrealized: followers.filter((node) => !node.established_by).length
+        },
+        by_type: Object.fromEntries(Object.entries(by_type).sort(([a, x], [b, y]) => sum(y) - sum(x) || (a < b ? -1 : a > b ? 1 : 0))),
+        other_claims: {
+            edges: input.graph.edges.length,
+            paths: input.graph.paths?.length ?? 0,
+            path_relations: input.graph.path_relations?.length ?? 0
+        },
+        ...(wanted.size
+            ? {
+                not_found: [...wanted]
+                    .filter((node) => !listed.some((entry) => entry.node === node))
+                    .sort()
+            }
+            : {}),
+        ...(asked
+            ? {
+                claims: listed.filter((node) => (!wanted.size || wanted.has(node.node)) &&
+                    (!input.status || node.status === input.status) &&
+                    (!input.stale_only || node.stale.length > 0) &&
+                    (!input.behind_only || node.behind.length > 0))
+            }
+            : {})
+    };
+}
+/** The Git reads of the repository holding `cwd`, through the git command. */
+export function gitClaimStatusReader(cwd) {
+    // git's exit status answers the question; failing to run git, or output past
+    // the buffer, is an error, never a negative answer.
+    const run = (args) => new Promise((resolve, reject) => {
+        execFile('git', ['-C', cwd, ...args], { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 }, (error, stdout) => {
+            if (!error)
+                return resolve({ code: 0, stdout });
+            const code = error.code;
+            if (typeof code === 'number')
+                return resolve({ code, stdout });
+            reject(new Error(`git ${args[0]} could not run: ${error.message.split('\n')[0]}`));
+        });
+    });
+    return {
+        async resolve(ref) {
+            const found = await run([
+                'rev-parse',
+                '--verify',
+                '--quiet',
+                `${ref}^{commit}`
+            ]);
+            return found.code === 0 ? found.stdout.trim() || null : null;
+        },
+        async isAncestor(commit, ref) {
+            return ((await run(['merge-base', '--is-ancestor', commit, ref])).code === 0);
+        },
+        async lines(commit, path) {
+            const found = await run(['show', `${commit}:${path}`]);
+            if (found.code !== 0)
+                return null;
+            // Git's lines: split on newlines only, never on form feeds.
+            const content = found.stdout;
+            if (!content)
+                return [];
+            const lines = content.split('\n');
+            return content.endsWith('\n') ? lines.slice(0, -1) : lines;
+        }
+    };
+}
+//# sourceMappingURL=workspace-claim-status.js.map